diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..53e7ee8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+Native/BytecodeEditor/Release
+Native/BytecodeEditor/Debug
+Native/BytecodeEditor/AdobeAIRSDK
+Native/BytecodeEditor/.vs
+Native/BytecodeEditor/.vscode
+Native/BytecodeEditor/BytecodeEditor.vcxproj.filters
+Native/BytecodeEditor/BytecodeEditor.vcxproj.user
+*.swc
+*.swf
+*.dll
+AS3/bin
+AS3/obj
diff --git a/ANEBytecodeEditor.ane b/ANEBytecodeEditor.ane
new file mode 100644
index 0000000..e719347
Binary files /dev/null and b/ANEBytecodeEditor.ane differ
diff --git a/AS3/ANEBytecodeEditorSWC.as3proj b/AS3/ANEBytecodeEditorSWC.as3proj
new file mode 100644
index 0000000..2da0727
--- /dev/null
+++ b/AS3/ANEBytecodeEditorSWC.as3proj
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<project version="2">
+  <!-- Output SWF options -->
+  <output>
+    <movie outputType="CustomBuild" />
+    <movie input="" />
+    <movie path="ANEBytecodeEditor.swc" />
+    <movie fps="0" />
+    <movie width="0" />
+    <movie height="0" />
+    <movie version="17" />
+    <movie minorVersion="0" />
+    <movie platform="AIR" />
+    <movie background="#FFFFFF" />
+  </output>
+  <!-- Other classes to be compiled into your SWF -->
+  <classpaths>
+    <class path="src" />
+  </classpaths>
+  <!-- Build options -->
+  <build>
+    <option accessible="False" />
+    <option advancedTelemetry="False" />
+    <option allowSourcePathOverlap="False" />
+    <option benchmark="False" />
+    <option es="False" />
+    <option inline="False" />
+    <option locale="" />
+    <option loadConfig="" />
+    <option optimize="True" />
+    <option omitTraces="True" />
+    <option showActionScriptWarnings="True" />
+    <option showBindingWarnings="True" />
+    <option showInvalidCSS="True" />
+    <option showDeprecationWarnings="True" />
+    <option showUnusedTypeSelectorWarnings="True" />
+    <option strict="True" />
+    <option useNetwork="True" />
+    <option useResourceBundleMetadata="True" />
+    <option warnings="True" />
+    <option verboseStackTraces="False" />
+    <option linkReport="" />
+    <option loadExterns="" />
+    <option staticLinkRSL="True" />
+    <option additional="-swf-version=11&#xA;--" />
+    <option compilerConstants="" />
+    <option minorVersion="" />
+  </build>
+  <!-- SWC Include Libraries -->
+  <includeLibraries>
+    <!-- example: <element path="..." /> -->
+  </includeLibraries>
+  <!-- SWC Libraries -->
+  <libraryPaths>
+    <!-- example: <element path="..." /> -->
+  </libraryPaths>
+  <!-- External Libraries -->
+  <externalLibraryPaths>
+    <!-- example: <element path="..." /> -->
+  </externalLibraryPaths>
+  <!-- Runtime Shared Libraries -->
+  <rslPaths>
+    <!-- example: <element path="..." /> -->
+  </rslPaths>
+  <!-- Intrinsic Libraries -->
+  <intrinsics>
+    <!-- example: <element path="..." /> -->
+  </intrinsics>
+  <!-- Assets to embed into the output SWF -->
+  <library>
+    <!-- example: <asset path="..." id="..." update="..." glyphs="..." mode="..." place="..." sharepoint="..." /> -->
+  </library>
+  <!-- Class files to compile (other referenced classes will automatically be included) -->
+  <compileTargets>
+    <!-- example: <compile path="..." /> -->
+  </compileTargets>
+  <!-- Paths to exclude from the Project Explorer tree -->
+  <hiddenPaths>
+    <hidden path="obj" />
+  </hiddenPaths>
+  <!-- Executed before build -->
+  <preBuildCommand>"$(BaseDir)\Tools\swcbuild\swcbuild.exe" "$(ProjectPath)" "-compiler=$(CompilerPath)" "-debug=$(BuildConfig)" "-library=C:\Program Files (x86)\FlashDevelop\Library" -asdoc=true -keep-asdoc=false</preBuildCommand>
+  <!-- Executed after build -->
+  <postBuildCommand alwaysRun="False" />
+  <!-- Other project options -->
+  <options>
+    <option showHiddenPaths="False" />
+    <option testMovie="Unknown" />
+    <option testMovieCommand="" />
+  </options>
+  <!-- Plugin storage -->
+  <storage />
+</project>
\ No newline at end of file
diff --git a/AS3/src/com/cff/anebe/AssemblyDoneEvent.as b/AS3/src/com/cff/anebe/AssemblyDoneEvent.as
new file mode 100644
index 0000000..b1722f4
--- /dev/null
+++ b/AS3/src/com/cff/anebe/AssemblyDoneEvent.as
@@ -0,0 +1,32 @@
+package com.cff.anebe 
+{
+	import flash.events.Event;
+	import flash.utils.ByteArray;
+	
+	/**
+	 * ...
+	 * @author Chris
+	 */
+	public class AssemblyDoneEvent extends Event 
+	{
+		public var assembled:ByteArray;
+		
+		public function AssemblyDoneEvent(assembled:ByteArray, bubbles:Boolean=false, cancelable:Boolean=false) 
+		{ 
+			super(Events.ASSEMBLY_DONE, bubbles, cancelable);
+			this.assembled = assembled;
+		} 
+		
+		public override function clone():Event 
+		{ 
+			return new AssemblyDoneEvent(assembled, bubbles, cancelable);
+		} 
+		
+		public override function toString():String 
+		{ 
+			return formatToString("AssemblyDoneEvent", "type", "bubbles", "cancelable", "eventPhase"); 
+		}
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/AS3/src/com/cff/anebe/BytecodeEditor.as b/AS3/src/com/cff/anebe/BytecodeEditor.as
new file mode 100644
index 0000000..bea49b3
--- /dev/null
+++ b/AS3/src/com/cff/anebe/BytecodeEditor.as
@@ -0,0 +1,367 @@
+package com.cff.anebe 
+{
+	import flash.events.EventDispatcher;
+	import flash.events.StatusEvent;
+	import flash.external.ExtensionContext;
+	import flash.utils.ByteArray;
+	import flash.utils.CompressionAlgorithm;
+	/**
+	 * ...
+	 * @author Chris
+	 */
+	public class BytecodeEditor extends EventDispatcher
+	{
+		private var extContext:ExtensionContext;
+		
+		public function BytecodeEditor() 
+		{
+			extContext = ExtensionContext.createExtensionContext("com.cff.anebe.ANEBytecodeEditor", "");
+			extContext.addEventListener(StatusEvent.STATUS, this.onStatusEvent);
+		}
+		
+		// Disassembles SWF into a map of file name to file contents
+		public function Disassemble(swf:ByteArray):Object
+		{
+			swf.position = 0;
+			var decompressor:ByteArray = new ByteArray();
+			switch (swf.readUTFBytes(1))
+			{
+				case "F":
+					swf.position = 0;
+					break;
+				case "C":
+					swf.position = 8;
+					swf.readBytes(decompressor);
+					swf.position = 8;
+					decompressor.uncompress(CompressionAlgorithm.ZLIB);
+					swf.writeBytes(decompressor);
+					swf.position = 0;
+					swf.writeUTFBytes("F");
+					swf.position = 0;
+					decompressor = null;
+					break;
+				case "Z":
+					swf.position = 8;
+					swf.readBytes(decompressor, 8);
+					swf.position = 8;
+					decompressor.uncompress(CompressionAlgorithm.LZMA);
+					swf.writeBytes(decompressor);
+					swf.position = 0;
+					swf.writeUTFBytes("F");
+					swf.position = 0;
+					decompressor = null;
+					break;
+				default:
+					throw new Error("Unrecognized compression scheme for SWF");
+			}
+			
+			var ret:Object = extContext.call("SetCurrentSWF", swf);
+			
+			if (ret == null)
+			{
+				throw new Error("Unknown error occurred while setting SWF");
+			}
+			else if (ret is String)
+			{
+				throw new Error(ret);
+			}
+			else // returned Boolean
+			{
+				if (!(ret as Boolean))
+				{
+					throw new Error("SetCurrentSWF returned false somehow");
+				}
+				else
+				{
+					ret = extContext.call("Disassemble");
+			
+					if (ret == null)
+					{
+						throw new Error("Unknown error occurred");
+					}
+					else if (ret is String)
+					{
+						throw new Error(ret);
+					}
+					else
+					{
+						return ret;
+					}
+				}
+			}
+		}
+		
+		// Assembles an SWF from a map of file name to file contents. If replaceSWF is unspecified, and Disassemble was called, uses
+		// the last SWF's data for the rest of the SWF.
+		public function Assemble(strings:Object, replaceSWF:ByteArray = null):ByteArray
+		{
+			if (replaceSWF != null)
+			{
+				replaceSWF.position = 0;
+				var decompressor:ByteArray = new ByteArray();
+				switch (replaceSWF.readUTFBytes(1))
+				{
+					case "F":
+						replaceSWF.position = 0;
+						break;
+					case "C":
+						replaceSWF.position = 8;
+						replaceSWF.readBytes(decompressor);
+						replaceSWF.position = 8;
+						decompressor.uncompress(CompressionAlgorithm.ZLIB);
+						replaceSWF.writeBytes(decompressor);
+						replaceSWF.position = 0;
+						replaceSWF.writeUTFBytes("F");
+						replaceSWF.position = 0;
+						decompressor = null;
+						break;
+					case "Z":
+						replaceSWF.position = 8;
+						replaceSWF.readBytes(decompressor, 8);
+						replaceSWF.position = 8;
+						decompressor.uncompress(CompressionAlgorithm.LZMA);
+						replaceSWF.writeBytes(decompressor);
+						replaceSWF.position = 0;
+						replaceSWF.writeUTFBytes("F");
+						replaceSWF.position = 0;
+						decompressor = null;
+						break;
+					default:
+						throw new Error("Unrecognized compression scheme for SWF");
+				}
+				
+				var ret:Object = extContext.call("SetCurrentSWF", replaceSWF);
+			
+				if (ret == null)
+				{
+					throw new Error("Unknown error occurred while setting SWF");
+				}
+				else if (ret is String)
+				{
+					throw new Error(ret);
+				}
+				else // returned Boolean
+				{
+					if (!(ret as Boolean))
+					{
+						throw new Error("SetCurrentSWF returned false somehow");
+					}
+				}
+			}
+			
+			var vec:Vector.<String> = new <String>[];
+			for (var str:String in strings)
+			{
+				vec[vec.length] = str;
+			}
+			
+			ret = extContext.call("Assemble", strings, vec);
+			
+			if (ret == null)
+			{
+				throw new Error("Unknown error occurred");
+			}
+			else if (ret is String)
+			{
+				throw new Error(ret);
+			}
+			else // byte array was returned
+			{
+				return ret as ByteArray;
+			}
+		}
+		
+		// Disassembles SWF into a map of file name to file contents, asynchronously
+		public function DisassembleAsync(swf:ByteArray):void
+		{
+			swf.position = 0;
+			var decompressor:ByteArray = new ByteArray();
+			switch (swf.readUTFBytes(1))
+			{
+				case "F":
+					swf.position = 0;
+					break;
+				case "C":
+					swf.position = 8;
+					swf.readBytes(decompressor);
+					swf.position = 8;
+					decompressor.uncompress(CompressionAlgorithm.ZLIB);
+					swf.writeBytes(decompressor);
+					swf.position = 0;
+					swf.writeUTFBytes("F");
+					swf.position = 0;
+					decompressor = null;
+					break;
+				case "Z":
+					swf.position = 8;
+					swf.readBytes(decompressor, 8);
+					swf.position = 8;
+					decompressor.uncompress(CompressionAlgorithm.LZMA);
+					swf.writeBytes(decompressor);
+					swf.position = 0;
+					swf.writeUTFBytes("F");
+					swf.position = 0;
+					decompressor = null;
+					break;
+				default:
+					throw new Error("Unrecognized compression scheme for SWF");
+			}
+			
+			var ret:Object = extContext.call("SetCurrentSWF", swf);
+			
+			if (ret == null)
+			{
+				throw new Error("Unknown error occurred while setting SWF");
+			}
+			else if (ret is String)
+			{
+				throw new Error(ret);
+			}
+			else // returned Boolean
+			{
+				if (!(ret as Boolean))
+				{
+					throw new Error("SetCurrentSWF returned false somehow");
+				}
+				else
+				{
+					ret = extContext.call("DisassembleAsync");
+			
+					if (ret == null)
+					{
+						throw new Error("Unknown error occurred during DisassembleAsync");
+					}
+					else if (ret is String)
+					{
+						throw new Error(ret);
+					}
+					else // Returned Boolean
+					{
+						if (!(ret as Boolean))
+						{
+							throw new Error("DisassembleAsync returned false somehow");
+						}
+					}
+				}
+			}
+		}
+		
+		// Assembles an SWF from a map of file name to file contents, asynchronously. If replaceSWF is unspecified, and Disassemble was called, uses
+		// the last SWF's data for the rest of the SWF.
+		public function AssembleAsync(strings:Object, replaceSWF:ByteArray = null):void
+		{
+			if (replaceSWF != null)
+			{
+				replaceSWF.position = 0;
+				var decompressor:ByteArray = new ByteArray();
+				switch (replaceSWF.readUTFBytes(1))
+				{
+					case "F":
+						replaceSWF.position = 0;
+						break;
+					case "C":
+						replaceSWF.position = 8;
+						replaceSWF.readBytes(decompressor);
+						replaceSWF.position = 8;
+						decompressor.uncompress(CompressionAlgorithm.ZLIB);
+						replaceSWF.writeBytes(decompressor);
+						replaceSWF.position = 0;
+						replaceSWF.writeUTFBytes("F");
+						replaceSWF.position = 0;
+						decompressor = null;
+						break;
+					case "Z":
+						replaceSWF.position = 8;
+						replaceSWF.readBytes(decompressor, 8);
+						replaceSWF.position = 8;
+						decompressor.uncompress(CompressionAlgorithm.LZMA);
+						replaceSWF.writeBytes(decompressor);
+						replaceSWF.position = 0;
+						replaceSWF.writeUTFBytes("F");
+						replaceSWF.position = 0;
+						decompressor = null;
+						break;
+					default:
+						throw new Error("Unrecognized compression scheme for SWF");
+				}
+				
+				var ret:Object = extContext.call("SetCurrentSWF", replaceSWF);
+			
+				if (ret == null)
+				{
+					throw new Error("Unknown error occurred while setting SWF");
+				}
+				else if (ret is String)
+				{
+					throw new Error(ret);
+				}
+				else // returned Boolean
+				{
+					if (!(ret as Boolean))
+					{
+						throw new Error("SetCurrentSWF returned false somehow");
+					}
+				}
+			}
+			
+			var vec:Vector.<String> = new <String>[];
+			for (var str:String in strings)
+			{
+				vec[vec.length] = str;
+			}
+			
+			ret = extContext.call("AssembleAsync", strings, vec);
+			
+			if (ret == null)
+			{
+				throw new Error("Unknown error occurred");
+			}
+			else if (ret is String)
+			{
+				throw new Error(ret);
+			}
+			else // returned Boolean
+			{
+				if (!(ret as Boolean))
+				{
+					throw new Error("AssembleAsync returned false somehow");
+				}
+			}
+		}
+		
+		public function Cleanup():void
+		{
+			extContext.call("Cleanup");
+		}
+		
+		private function onStatusEvent(e:StatusEvent):void
+		{
+			if (e.level == "ERROR")
+			{
+				var error:Object = extContext.call("AsyncTaskResult");
+				if (error is String)
+				{
+					throw new Error(error);
+				}
+				else
+				{
+					throw new Error("Unknown error occurred while performing an ANEByteCodeEditor async task");
+				}
+			}
+			else
+			{
+				var data:Object = extContext.call("AsyncTaskResult");
+				
+				if (data is ByteArray)
+				{
+					this.dispatchEvent(new AssemblyDoneEvent(data as ByteArray));
+				}
+				else
+				{
+					this.dispatchEvent(new DisassemblyDoneEvent(data));
+				}
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/AS3/src/com/cff/anebe/DisassemblyDoneEvent.as b/AS3/src/com/cff/anebe/DisassemblyDoneEvent.as
new file mode 100644
index 0000000..3c8d627
--- /dev/null
+++ b/AS3/src/com/cff/anebe/DisassemblyDoneEvent.as
@@ -0,0 +1,31 @@
+package com.cff.anebe 
+{
+	import flash.events.Event;
+	
+	/**
+	 * ...
+	 * @author Chris
+	 */
+	public class DisassemblyDoneEvent extends Event 
+	{
+		public var strings:Object;
+		public function DisassemblyDoneEvent(strings:Object, bubbles:Boolean=false, cancelable:Boolean=false) 
+		{ 
+			super(Events.DISASSEMBLY_DONE, bubbles, cancelable);
+			
+			this.strings = strings;
+		} 
+		
+		public override function clone():Event 
+		{ 
+			return new DisassemblyDoneEvent(strings, bubbles, cancelable);
+		} 
+		
+		public override function toString():String 
+		{ 
+			return formatToString("DisassemblyDoneEvent", "type", "bubbles", "cancelable", "eventPhase"); 
+		}
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/AS3/src/com/cff/anebe/Events.as b/AS3/src/com/cff/anebe/Events.as
new file mode 100644
index 0000000..d3fa439
--- /dev/null
+++ b/AS3/src/com/cff/anebe/Events.as
@@ -0,0 +1,13 @@
+package com.cff.anebe 
+{
+	/**
+	 * ...
+	 * @author Chris
+	 */
+	public final class Events 
+	{
+		public static const ASSEMBLY_DONE:String = "ASSEMBLY_DONE";
+		public static const DISASSEMBLY_DONE:String = "DISASSEMBLY_DONE";
+	}
+
+}
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..4619efa
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Chris Feger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Native/BytecodeEditor/BytecodeEditor.sln b/Native/BytecodeEditor/BytecodeEditor.sln
new file mode 100644
index 0000000..a443173
--- /dev/null
+++ b/Native/BytecodeEditor/BytecodeEditor.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BytecodeEditor", "BytecodeEditor.vcxproj", "{76827AD2-1616-45C5-8FE5-58E26AF91B3D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{76827AD2-1616-45C5-8FE5-58E26AF91B3D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{76827AD2-1616-45C5-8FE5-58E26AF91B3D}.Debug|Win32.Build.0 = Debug|Win32
+		{76827AD2-1616-45C5-8FE5-58E26AF91B3D}.Release|Win32.ActiveCfg = Release|Win32
+		{76827AD2-1616-45C5-8FE5-58E26AF91B3D}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/Native/BytecodeEditor/BytecodeEditor.vcxproj b/Native/BytecodeEditor/BytecodeEditor.vcxproj
new file mode 100644
index 0000000..5f9fa71
--- /dev/null
+++ b/Native/BytecodeEditor/BytecodeEditor.vcxproj
@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{76827AD2-1616-45C5-8FE5-58E26AF91B3D}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>FRESteamWorks</RootNamespace>
+    <ProjectName>BytecodeEditor</ProjectName>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>USE_BREAKPAD_HANDLER;VERSION_SAFE_STEAM_API_INTERFACES;WIN32;_DEBUG;_WINDOWS;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)\AdobeAIRSDK\include;$(SolutionDir)SteamSDK\public;$(ProjectDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <DisableSpecificWarnings>4068</DisableSpecificWarnings>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)AdobeAIRSDK\lib\win;$(SolutionDir)SteamSDK\redistributable_bin;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>steam_api.lib;FlashRuntimeExtensions.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>USE_BREAKPAD_HANDLER;VERSION_SAFE_STEAM_API_INTERFACES;WIN32;NDEBUG;_WINDOWS;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)\AdobeAIRSDK\include;$(ProjectDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <DisableSpecificWarnings>4068</DisableSpecificWarnings>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>$(SolutionDir)AdobeAIRSDK\lib\win;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>FlashRuntimeExtensions.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <ProjectReference>
+      <LinkLibraryDependencies>true</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+    <ClCompile>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">stdcpp20</LanguageStandard>
+    </ClCompile>
+    <ClCompile>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">stdcpp20</LanguageStandard>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="source\ASASM\ASProgram.cpp" />
+    <ClCompile Include="source\ANEBytecodeEditor.cpp" />
+    <ClCompile Include="source\BytecodeEditor.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="include\ABC\ABCFile.hpp" />
+    <ClInclude Include="include\ABC\ABCReader.hpp" />
+    <ClInclude Include="include\ABC\ABCWriter.hpp" />
+    <ClInclude Include="include\ABC\Class.hpp" />
+    <ClInclude Include="include\ABC\Error.hpp" />
+    <ClInclude Include="include\ABC\ExceptionInfo.hpp" />
+    <ClInclude Include="include\ABC\Instance.hpp" />
+    <ClInclude Include="include\ABC\Instruction.hpp" />
+    <ClInclude Include="include\ABC\Label.hpp" />
+    <ClInclude Include="include\ABC\Metadata.hpp" />
+    <ClInclude Include="include\ABC\MethodBody.hpp" />
+    <ClInclude Include="include\ABC\MethodInfo.hpp" />
+    <ClInclude Include="include\ABC\Multiname.hpp" />
+    <ClInclude Include="include\ABC\Namespace.hpp" />
+    <ClInclude Include="include\ABC\OptionDetail.hpp" />
+    <ClInclude Include="include\ABC\Script.hpp" />
+    <ClInclude Include="include\ABC\TraitsInfo.hpp" />
+    <ClInclude Include="include\ANEBytecodeEditor.hpp" />
+    <ClInclude Include="include\ASASM\ASProgram.hpp" />
+    <ClInclude Include="include\ASASM\AStoABC.hpp" />
+    <ClInclude Include="include\ASASM\ASTraitsVisitor.hpp" />
+    <ClInclude Include="include\ASASM\Class.hpp" />
+    <ClInclude Include="include\ASASM\Exception.hpp" />
+    <ClInclude Include="include\ASASM\Instance.hpp" />
+    <ClInclude Include="include\ASASM\Instruction.hpp" />
+    <ClInclude Include="include\ASASM\Metadata.hpp" />
+    <ClInclude Include="include\ASASM\Method.hpp" />
+    <ClInclude Include="include\ASASM\MethodBody.hpp" />
+    <ClInclude Include="include\ASASM\Multiname.hpp" />
+    <ClInclude Include="include\ASASM\Namespace.hpp" />
+    <ClInclude Include="include\ASASM\Script.hpp" />
+    <ClInclude Include="include\ASASM\Trait.hpp" />
+    <ClInclude Include="include\ASASM\Value.hpp" />
+    <ClInclude Include="include\Assembler.hpp" />
+    <ClInclude Include="include\BytecodeEditor.hpp" />
+    <ClInclude Include="include\Disassembler.hpp" />
+    <ClInclude Include="include\enums\ABCType.hpp" />
+    <ClInclude Include="include\enums\InstanceFlags.hpp" />
+    <ClInclude Include="include\enums\MethodFlags.hpp" />
+    <ClInclude Include="include\enums\OPCode.hpp" />
+    <ClInclude Include="include\enums\OPCodeArgumentType.hpp" />
+    <ClInclude Include="include\enums\TagType.hpp" />
+    <ClInclude Include="include\enums\TraitAttribute.hpp" />
+    <ClInclude Include="include\enums\TraitKind.hpp" />
+    <ClInclude Include="include\SWF\SWFFile.hpp" />
+    <ClInclude Include="include\utils\ANEUtils.hpp" />
+    <ClInclude Include="include\utils\BidirectionalMap.hpp" />
+    <ClInclude Include="include\utils\RefBuilder.hpp" />
+    <ClInclude Include="include\utils\SmallTrivialVector.hpp" />
+    <ClInclude Include="include\utils\StringBuilder.hpp" />
+    <ClInclude Include="include\utils\StringException.hpp" />
+    <ClInclude Include="include\utils\StringUtils.hpp" />
+    <ClInclude Include="include\utils\ValuePool.hpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/Native/BytecodeEditor/include/ABC/ABCFile.hpp b/Native/BytecodeEditor/include/ABC/ABCFile.hpp
new file mode 100644
index 0000000..8d2d688
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/ABCFile.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "ABC/Class.hpp"
+#include "ABC/Instance.hpp"
+#include "ABC/Metadata.hpp"
+#include "ABC/MethodBody.hpp"
+#include "ABC/MethodInfo.hpp"
+#include "ABC/Multiname.hpp"
+#include "ABC/Namespace.hpp"
+#include "ABC/Script.hpp"
+#include <stdint.h>
+#include <string>
+
+namespace ABC
+{
+    struct ABCFile
+    {
+        uint16_t minorVersion, majorVersion;
+        std::vector<int64_t> ints;
+        std::vector<uint64_t> uints;
+        std::vector<double> doubles;
+        std::vector<std::string> strings;
+        std::vector<Namespace> namespaces;
+        std::vector<std::vector<int32_t>> namespaceSets;
+        std::vector<Multiname> multinames;
+
+        std::vector<MethodInfo> methods;
+        std::vector<Metadata> metadata;
+        std::vector<Instance> instances;
+        std::vector<Class> classes;
+        std::vector<Script> scripts;
+        std::vector<MethodBody> bodies;
+
+        static constexpr int64_t NULL_INT   = INT64_MAX;
+        static constexpr uint64_t NULL_UINT = UINT64_MAX;
+        static constexpr double NULL_DOUBLE = std::numeric_limits<double>::quiet_NaN();
+
+        static constexpr uint64_t MAX_UINT = (((uint64_t)1) << 36) - 1;
+        static constexpr int64_t MAX_INT   = MAX_UINT / 2;
+        static constexpr int64_t MIN_INT   = -MAX_INT - 1;
+
+        ABCFile()
+        {
+            majorVersion = 46;
+            minorVersion = 16;
+
+            ints    = {NULL_INT};
+            uints   = {NULL_UINT};
+            doubles = {NULL_DOUBLE};
+
+            strings       = {""};
+            namespaces    = {{}};
+            namespaceSets = {{}};
+            multinames    = {{}};
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/ABCReader.hpp b/Native/BytecodeEditor/include/ABC/ABCReader.hpp
new file mode 100644
index 0000000..de69bd0
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/ABCReader.hpp
@@ -0,0 +1,715 @@
+#pragma once
+
+#include "ABC/ABCFile.hpp"
+#include "ABC/Class.hpp"
+#include "ABC/Error.hpp"
+#include "ABC/ExceptionInfo.hpp"
+#include "ABC/Instance.hpp"
+#include "ABC/Instruction.hpp"
+#include "ABC/Label.hpp"
+#include "ABC/Metadata.hpp"
+#include "ABC/MethodBody.hpp"
+#include "ABC/MethodInfo.hpp"
+#include "ABC/Multiname.hpp"
+#include "ABC/Namespace.hpp"
+#include "ABC/OptionDetail.hpp"
+#include "ABC/Script.hpp"
+#include "ABC/TraitsInfo.hpp"
+#include "enums/ABCType.hpp"
+#include "enums/InstanceFlags.hpp"
+#include "enums/MethodFlags.hpp"
+#include "enums/OPCode.hpp"
+#include "enums/OPCodeArgumentType.hpp"
+#include "enums/TraitAttribute.hpp"
+#include "enums/TraitKind.hpp"
+#include "utils/StringException.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <exception>
+#include <limits>
+#include <stdint.h>
+#include <string>
+
+namespace ABC
+{
+    class ABCReader
+    {
+    private:
+        const uint8_t* buf;
+        size_t len;
+        size_t pos;
+        ABCFile _abc;
+
+        static constexpr auto setTable = [](auto& table, size_t number, auto readFunc,
+                                             size_t start = 0) {
+            table.reserve(number + start);
+            for (size_t i = start; i < number; i++)
+            {
+                table.emplace_back(std::invoke(readFunc));
+            }
+        };
+
+    public:
+        ABCFile& abc() { return _abc; }
+        const ABCFile& abc() const { return _abc; }
+
+        ABCReader(std::pair<const uint8_t*, size_t> d) : ABCReader(d.first, d.second) {}
+        ABCReader(const uint8_t* data, size_t len) : buf(data), len(len), pos(0)
+        {
+            _abc.minorVersion = readU16();
+            _abc.majorVersion = readU16();
+
+            const auto atLeastOne = [](uint32_t n) { return n == 0 ? 1 : n; };
+
+            try
+            {
+                setTable(
+                    _abc.ints, atLeastOne(readU30()), [&] { return readS32(); }, 1);
+                setTable(
+                    _abc.uints, atLeastOne(readU30()), [&] { return readU32(); }, 1);
+                setTable(
+                    _abc.doubles, atLeastOne(readU30()), [&] { return readD64(); }, 1);
+                setTable(
+                    _abc.strings, atLeastOne(readU30()), [&] { return readString(); }, 1);
+                setTable(
+                    _abc.namespaces, atLeastOne(readU30()), [&] { return readNamespace(); }, 1);
+                setTable(
+                    _abc.namespaceSets, atLeastOne(readU30()), [&] { return readNamespaceSet(); },
+                    1);
+                setTable(
+                    _abc.multinames, atLeastOne(readU30()), [&] { return readMultiname(); }, 1);
+
+                setTable(_abc.methods, readU30(), [&] { return readMethodInfo(); });
+                setTable(_abc.metadata, readU30(), [&] { return readMetadata(); });
+                setTable(_abc.instances, readU30(), [&] { return readInstance(); });
+                setTable(_abc.classes, _abc.instances.size(), [&] { return readClass(); });
+                setTable(_abc.scripts, readU30(), [&] { return readScript(); });
+                setTable(_abc.bodies, readU30(), [&] { return readMethodBody(); });
+            }
+            catch (std::exception& e)
+            {
+                char print[256] = {'\0'};
+                sprintf(print, "Error at %d (0x%X): ", pos, pos);
+                throw StringException(std::string(print) + e.what());
+            }
+        }
+
+        uint8_t readU8()
+        {
+            if (pos >= len)
+                throw StringException("End of file reached");
+            return buf[pos++];
+        }
+
+        uint16_t readU16() { return readU8() | (readU8() << 8); }
+
+        int32_t readS24()
+        {
+            uint32_t val = readU8() | (readU8() << 8) | (readU8() << 16);
+            if (val & 0x00800000)
+            {
+                val |= 0xFF000000;
+            }
+            return val;
+        }
+
+        uint64_t readU32()
+        {
+            const auto next = [this]() -> uint64_t { return readU8(); };
+
+            uint64_t result = next();
+            if (!(result & 0x80))
+                return result;
+            result = (result & 0x7F) | (next() << 7);
+            if (!(result & 0x40'00))
+                return result;
+            result = (result & 0x3F'FF) | (next() << 14);
+            if (!(result & 0x20'00'00))
+                return result;
+            result = (result & 0x1F'FF'FF) | (next() << 21);
+            if (!(result & 0x10'00'00'00))
+                return result;
+            result = (result & 0x0F'FF'FF'FF) | (next() << 28);
+
+            assert(result <= ABCFile::MAX_UINT);
+            return result;
+        }
+
+        int64_t readS32()
+        {
+            int64_t ret = readU32();
+            if (ret & 0xFFFFFFFF'80000000)
+            {
+                ret |= 0xFFFFFFFF'00000000;
+            }
+
+            assert(ret >= ABCFile::MIN_INT && ret <= ABCFile::MAX_INT);
+            return ret;
+        }
+
+        uint32_t readU30() { return readU32() & 0x3FFFFFFF; }
+
+        void readExact(std::vector<uint8_t>& data, size_t size)
+        {
+            if (pos + size > this->len)
+                throw StringException("End of file reached");
+            data.clear();
+            data.insert(data.begin(), buf + pos, buf + pos + size);
+            pos += size;
+        }
+
+        void readExact(void* data, size_t size)
+        {
+            if (pos + size > this->len)
+                throw StringException("End of file reached");
+            memcpy(data, buf + pos, size);
+            pos += size;
+        }
+
+        double readD64()
+        {
+            double ret;
+            static_assert(std::numeric_limits<decltype(ret)>::is_iec559);
+            // static_assert(std::endian::native == std::endian::little);
+            readExact(&ret, sizeof(ret));
+            return ret;
+        }
+
+        std::string readString()
+        {
+            std::string ret(readU30(), '\0');
+            readExact(ret.data(), ret.size());
+            return ret;
+        }
+
+        std::vector<uint8_t> readBytes()
+        {
+            std::vector<uint8_t> ret(readU30(), 0);
+            readExact(ret.data(), ret.size());
+            return ret;
+        }
+
+        Namespace readNamespace() { return {ABCType(readU8()), readU30()}; }
+
+        std::vector<int32_t> readNamespaceSet()
+        {
+            std::vector<int32_t> ret(readU30(), 0);
+            for (auto& v : ret)
+            {
+                v = readU30();
+            }
+            return ret;
+        }
+
+        Multiname readMultiname()
+        {
+            Multiname ret;
+            ret.kind = ABCType(readU8());
+            switch (ret.kind)
+            {
+                case ABCType::QName:
+                case ABCType::QNameA:
+                    ret.qname({readU30(), readU30()});
+                    break;
+                case ABCType::RTQName:
+                case ABCType::RTQNameA:
+                    ret.rtqname({readU30()});
+                    break;
+                case ABCType::RTQNameL:
+                case ABCType::RTQNameLA:
+                    ret.rtqnamel({});
+                    break;
+                case ABCType::Multiname:
+                case ABCType::MultinameA:
+                    ret.multiname({readU30(), readU30()});
+                    break;
+                case ABCType::MultinameL:
+                case ABCType::MultinameLA:
+                    ret.multinamel({readU30()});
+                    break;
+                case ABCType::TypeName:
+                {
+                    Multiname::_Typename tname{readU30(), std::vector<uint32_t>(readU30(), 0)};
+                    for (auto& v : tname.params)
+                    {
+                        v = readU30();
+                    }
+                    ret.Typename(std::move(tname));
+                }
+                break;
+                default:
+                    throw StringException("Unknown multiname type");
+            }
+
+            return ret;
+        }
+
+        MethodInfo readMethodInfo()
+        {
+            MethodInfo ret;
+            size_t tempSize = readU30();
+            ret.paramTypes.reserve(tempSize);
+            ret.returnType = readU30();
+            for (size_t i = 0; i < tempSize; i++)
+            {
+                ret.paramTypes.emplace_back(readU30());
+            }
+            ret.name  = readU30();
+            ret.flags = readU8();
+            if (ret.flags & uint8_t(MethodFlags::HAS_OPTIONAL))
+            {
+                tempSize = readU30();
+                ret.options.reserve(tempSize);
+                for (size_t i = 0; i < tempSize; i++)
+                {
+                    ret.options.emplace_back(readOptionDetail());
+                }
+            }
+            if (ret.flags & uint8_t(MethodFlags::HAS_PARAM_NAMES))
+            {
+                ret.paramNames.reserve(ret.paramTypes.size());
+                for (size_t i = 0; i < ret.paramTypes.size(); i++)
+                {
+                    ret.paramNames.emplace_back(readU30());
+                }
+            }
+            return ret;
+        }
+
+        OptionDetail readOptionDetail() { return {readU30(), ABCType(readU8())}; }
+
+        Metadata readMetadata()
+        {
+            Metadata ret{readU30(), std::vector<std::pair<uint32_t, uint32_t>>(readU30())};
+            for (auto& v : ret.data)
+            {
+                v = {readU30(), readU30()};
+            }
+            return ret;
+        }
+
+        Instance readInstance()
+        {
+            Instance ret;
+            ret.name      = readU30();
+            ret.superName = readU30();
+            ret.flags     = readU8();
+            if (ret.flags & uint8_t(InstanceFlags::ProtectedNs))
+                ret.protectedNs = readU30();
+            size_t tempSize = readU30();
+            ret.interfaces.reserve(tempSize);
+            for (size_t i = 0; i < tempSize; i++)
+            {
+                ret.interfaces.emplace_back(readU30());
+            }
+            ret.iinit = readU30();
+            tempSize  = readU30();
+            ret.traits.reserve(tempSize);
+            for (size_t i = 0; i < tempSize; i++)
+            {
+                ret.traits.emplace_back(readTrait());
+            }
+
+            return ret;
+        }
+
+        TraitsInfo readTrait()
+        {
+            TraitsInfo ret;
+            ret.name     = readU30();
+            ret.kindAttr = readU8();
+
+            switch (ret.kind())
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    ret.Slot.slotId   = readU30();
+                    ret.Slot.typeName = readU30();
+                    ret.Slot.vindex   = readU30();
+                    if (ret.Slot.vindex != 0)
+                    {
+                        ret.Slot.vkind = ABCType(readU8());
+                    }
+                    else
+                    {
+                        ret.Slot.vkind = ABCType::Void;
+                    }
+                    break;
+                case TraitKind::Class:
+                    ret.Class = {readU30(), readU30()};
+                    break;
+                case TraitKind::Function:
+                    ret.Function = {readU30(), readU30()};
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    ret.Method = {readU30(), readU30()};
+                    break;
+                default:
+                    throw StringException(
+                        "Unknown trait type" + std::to_string((uint32_t)ret.kindAttr));
+            }
+            if (ret.attr() & uint8_t(TraitAttribute::Metadata))
+            {
+                size_t tempSize = readU30();
+                ret.metadata.reserve(tempSize);
+                for (size_t i = 0; i < tempSize; i++)
+                {
+                    ret.metadata.emplace_back(readU30());
+                }
+            }
+            return ret;
+        }
+
+        Class readClass()
+        {
+            Class ret{readU30(), std::vector<TraitsInfo>(readU30())};
+            for (auto& v : ret.traits)
+            {
+                v = readTrait();
+            }
+            return ret;
+        }
+
+        Script readScript()
+        {
+            Script ret{readU30(), std::vector<TraitsInfo>(readU30())};
+            for (auto& v : ret.traits)
+            {
+                v = readTrait();
+            }
+            return ret;
+        }
+
+        MethodBody readMethodBody()
+        {
+            MethodBody ret;
+            ret.method         = readU30();
+            ret.maxStack       = readU30();
+            ret.localCount     = readU30();
+            ret.initScopeDepth = readU30();
+            ret.maxScopeDepth  = readU30();
+
+            size_t len   = readU30();
+            size_t start = pos;
+            size_t end   = pos + len;
+
+            pos = end;
+
+            setTable(ret.exceptions, readU30(), [&] { return readExceptionInfo(); });
+
+            size_t postExceptions = pos;
+
+            enum class TraceState : uint8_t
+            {
+                unexplored,
+                pending,
+                instruction,
+                instructionBody,
+                error
+            };
+
+            std::vector<TraceState> traceState(len, TraceState::unexplored);
+            std::vector<Instruction> instructions(len);
+
+            const auto offset = [&] { return pos - start; };
+
+            bool done = false;
+
+            const auto queue = [&](size_t traceOffset) {
+                if (traceOffset < len && traceState[traceOffset] == TraceState::unexplored)
+                {
+                    traceState[traceOffset] = TraceState::pending;
+                    done                    = false;
+                }
+            };
+
+            queue(0);
+
+            for (const auto& exception : ret.exceptions)
+            {
+                queue(exception.target.absoluteOffset);
+            }
+
+            while (!done)
+            {
+                done = true;
+                pos  = start;
+                while (pos < end)
+                {
+                    if (traceState[offset()] == TraceState::pending)
+                    {
+                        size_t instructionOffset;
+
+                        try
+                        {
+                            while (pos < end)
+                            {
+                                instructionOffset = offset();
+                                if (traceState[instructionOffset] == TraceState::instructionBody)
+                                    throw StringException("Overlapping instruction");
+                                if (traceState[instructionOffset] == TraceState::instruction)
+                                    break; // already decoded
+
+                                Instruction instruction;
+                                instruction.opcode = OPCode(readU8());
+                                if (instruction.opcode == OPCode::OP_raw)
+                                    throw StringException("Null OPCode");
+
+                                instruction.arguments.resize(
+                                    OPCode_Info[(uint8_t)instruction.opcode].second.size());
+
+                                for (size_t i = 0; i < instruction.arguments.size(); i++)
+                                {
+                                    switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                                    {
+                                        case OPCodeArgumentType::Unknown:
+                                            throw StringException(
+                                                "Don't know how to decode OP_" +
+                                                std::string(OPCode_Info[(uint8_t)instruction.opcode]
+                                                                .first));
+
+                                        case OPCodeArgumentType::ByteLiteral:
+                                            instruction.arguments[i].bytev(readU8());
+                                            break;
+                                        case OPCodeArgumentType::UByteLiteral:
+                                            instruction.arguments[i].ubytev(readU8());
+                                            break;
+                                        case OPCodeArgumentType::IntLiteral:
+                                            instruction.arguments[i].intv(readS32());
+                                            break;
+                                        case OPCodeArgumentType::UIntLiteral:
+                                            instruction.arguments[i].uintv(readU32());
+                                            break;
+
+                                        case OPCodeArgumentType::Int:
+                                        case OPCodeArgumentType::UInt:
+                                        case OPCodeArgumentType::Double:
+                                        case OPCodeArgumentType::String:
+                                        case OPCodeArgumentType::Namespace:
+                                        case OPCodeArgumentType::Multiname:
+                                        case OPCodeArgumentType::Class:
+                                        case OPCodeArgumentType::Method:
+                                        {
+                                            size_t index = readU30();
+                                            size_t length;
+                                            switch (
+                                                OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                                            {
+                                                case OPCodeArgumentType::Int:
+                                                    length = _abc.ints.size();
+                                                    break;
+                                                case OPCodeArgumentType::UInt:
+                                                    length = _abc.uints.size();
+                                                    break;
+                                                case OPCodeArgumentType::Double:
+                                                    length = _abc.doubles.size();
+                                                    break;
+                                                case OPCodeArgumentType::String:
+                                                    length = _abc.strings.size();
+                                                    break;
+                                                case OPCodeArgumentType::Namespace:
+                                                    length = _abc.namespaces.size();
+                                                    break;
+                                                case OPCodeArgumentType::Multiname:
+                                                    length = _abc.multinames.size();
+                                                    break;
+                                                case OPCodeArgumentType::Class:
+                                                    length = _abc.classes.size();
+                                                    break;
+                                                case OPCodeArgumentType::Method:
+                                                    length = _abc.methods.size();
+                                                    break;
+                                                default:
+                                                    assert(false);
+                                            }
+                                            if (index >= length)
+                                                throw StringException(
+                                                    "Out of bounds constant index");
+                                            instruction.arguments[i].index(index);
+                                        }
+                                        break;
+
+                                        case OPCodeArgumentType::JumpTarget:
+                                        {
+                                            int32_t delta  = readS24();
+                                            int32_t target = offset() + delta;
+                                            instruction.arguments[i].jumpTarget(
+                                                Label{.absoluteOffset = target});
+                                            queue(target);
+                                        }
+                                        break;
+
+                                        case OPCodeArgumentType::SwitchDefaultTarget:
+                                        {
+                                            int32_t target = instructionOffset + readS24();
+                                            instruction.arguments[i].jumpTarget(
+                                                Label{.absoluteOffset = target});
+                                            queue(target);
+                                        }
+                                        break;
+
+                                        case OPCodeArgumentType::SwitchTargets:
+                                        {
+                                            std::vector<Label> switchTargets(readU30() + 1);
+                                            for (Label& label : switchTargets)
+                                            {
+                                                label.absoluteOffset =
+                                                    instructionOffset + readS24();
+                                                queue(label.absoluteOffset);
+                                            }
+
+                                            instruction.arguments[i].switchTargets(
+                                                std::move(switchTargets));
+                                        }
+                                        break;
+                                    }
+                                }
+
+                                if (offset() > len)
+                                    throw StringException("Out-of-bounds code read error");
+
+                                instructions[instructionOffset] = instruction;
+                                traceState[instructionOffset]   = TraceState::instruction;
+                                for (size_t i = instructionOffset + 1; i < offset(); i++)
+                                {
+                                    traceState[i] = TraceState::instructionBody;
+                                }
+
+                                // if (stopsExecution[instruction.opcode])
+                                //   break;
+                            }
+                        }
+                        catch (std::exception& e)
+                        {
+                            traceState[instructionOffset] = TraceState::error;
+                            Label loc{.absoluteOffset = (ptrdiff_t)instructionOffset};
+                            ret.errors.emplace_back(loc, e.what());
+
+                            pos = start + instructionOffset + 1;
+                        }
+                    }
+                    else
+                    {
+                        pos++;
+                    }
+                }
+            }
+
+            std::vector<size_t> instructionOffsets;
+            std::vector<uint32_t> instructionAtOffset(len, UINT32_MAX);
+
+            const auto addInstruction = [&](const Instruction& i, size_t offset) {
+                instructionAtOffset[offset] = ret.instructions.size();
+                ret.instructions.emplace_back(i);
+                instructionOffsets.emplace_back(offset);
+            };
+
+            for (size_t currentOffset = 0; currentOffset < traceState.size(); currentOffset++)
+            {
+                assert(traceState[currentOffset] != TraceState::pending);
+                if (traceState[currentOffset] == TraceState::instruction)
+                {
+                    addInstruction(instructions[currentOffset], currentOffset);
+                }
+                else if (traceState[currentOffset] == TraceState::unexplored ||
+                         traceState[currentOffset] == TraceState::error)
+                {
+                    Instruction instruction;
+                    instruction.opcode = OPCode::OP_raw;
+                    instruction.arguments.resize(1);
+                    instruction.arguments[0].ubytev(buf[start + currentOffset]);
+                    addInstruction(instruction, currentOffset);
+                }
+                else
+                {
+                    assert(traceState[currentOffset] == TraceState::instructionBody);
+                }
+            }
+
+            const auto translateLabel = [&](Label& label) {
+                ptrdiff_t absoluteOffset    = label.absoluteOffset;
+                ptrdiff_t instructionOffset = absoluteOffset;
+
+                while (true)
+                {
+                    if (instructionOffset >= len)
+                    {
+                        label = {.index = (uint32_t)ret.instructions.size(), .offset = 0};
+                        instructionOffset = len;
+                        break;
+                    }
+                    if (instructionOffset <= 0)
+                    {
+                        label             = {.index = 0, .offset = 0};
+                        instructionOffset = 0;
+                        break;
+                    }
+                    if (instructionAtOffset[instructionOffset] != UINT32_MAX)
+                    {
+                        label = {.index = instructionAtOffset[instructionOffset], .offset = 0};
+                        break;
+                    }
+                    instructionOffset--;
+                }
+                label.offset = (int32_t)(absoluteOffset - instructionOffset);
+            };
+
+            for (auto& instruction : ret.instructions)
+            {
+                for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size(); i++)
+                {
+                    switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                    {
+                        case OPCodeArgumentType::JumpTarget:
+                        case OPCodeArgumentType::SwitchDefaultTarget:
+                            translateLabel(instruction.arguments[i].jumpTarget());
+                            break;
+                        case OPCodeArgumentType::SwitchTargets:
+                        {
+                            for (auto& label : instruction.arguments[i].switchTargets())
+                            {
+                                translateLabel(label);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto& error : ret.errors)
+            {
+                translateLabel(error.loc);
+            }
+
+            for (auto& exception : ret.exceptions)
+            {
+                translateLabel(exception.from);
+                translateLabel(exception.to);
+                translateLabel(exception.target);
+            }
+
+            pos = postExceptions;
+
+            size_t tempSize = readU30();
+            ret.traits.reserve(tempSize);
+            for (size_t i = 0; i < tempSize; i++)
+            {
+                ret.traits.emplace_back(readTrait());
+            }
+
+            return ret;
+        }
+
+        ExceptionInfo readExceptionInfo()
+        {
+            return {.from = {.absoluteOffset = (ptrdiff_t)readU30()},
+                .to       = {.absoluteOffset = (ptrdiff_t)readU30()},
+                .target   = {.absoluteOffset = (ptrdiff_t)readU30()},
+                .excType  = readU30(),
+                .varName  = readU30()};
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/ABCWriter.hpp b/Native/BytecodeEditor/include/ABC/ABCWriter.hpp
new file mode 100644
index 0000000..8d6ec66
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/ABCWriter.hpp
@@ -0,0 +1,491 @@
+// TODO: Test
+#pragma once
+
+#include "ABC/ABCFile.hpp"
+#include "ABC/Class.hpp"
+#include "ABC/Error.hpp"
+#include "ABC/ExceptionInfo.hpp"
+#include "ABC/Instance.hpp"
+#include "ABC/Instruction.hpp"
+#include "ABC/Label.hpp"
+#include "ABC/Metadata.hpp"
+#include "ABC/MethodBody.hpp"
+#include "ABC/MethodInfo.hpp"
+#include "ABC/Multiname.hpp"
+#include "ABC/Namespace.hpp"
+#include "ABC/OptionDetail.hpp"
+#include "ABC/Script.hpp"
+#include "ABC/TraitsInfo.hpp"
+#include "enums/ABCType.hpp"
+#include "enums/InstanceFlags.hpp"
+#include "enums/MethodFlags.hpp"
+#include "enums/OPCode.hpp"
+#include "enums/OPCodeArgumentType.hpp"
+#include "enums/TraitAttribute.hpp"
+#include "enums/TraitKind.hpp"
+#include "utils/StringException.hpp"
+
+#include <cassert>
+#include <limits>
+#include <stdint.h>
+#include <string>
+
+namespace ABC
+{
+    class ABCWriter
+    {
+    private:
+        std::vector<uint8_t> buf;
+        size_t pos;
+        const ABCFile& _abc;
+
+        static constexpr auto writeTable = [](const auto& table, auto writeFunc, size_t start = 0) {
+            for (size_t i = start; i < table.size(); i++)
+            {
+                writeFunc(table[i]);
+            }
+        };
+
+    public:
+        [[nodiscard]] const ABCFile& abc() const { return _abc; }
+
+        [[nodiscard]] std::vector<uint8_t>& data() { return buf; }
+        [[nodiscard]] const std::vector<uint8_t>& data() const { return buf; }
+
+        ABCWriter(const ABCFile& _abc) : _abc(_abc), pos(0), buf(std::vector<uint8_t>(1024))
+        {
+            writeU16(_abc.minorVersion);
+            writeU16(_abc.majorVersion);
+
+            auto oneToZero = [](size_t n) { return n <= 1 ? 0 : n; };
+
+            writeU30(oneToZero(_abc.ints.size()));
+            writeTable(
+                _abc.ints, [this](auto v) { writeS32(v); }, 1);
+            writeU30(oneToZero(_abc.uints.size()));
+            writeTable(
+                _abc.uints, [this](auto v) { writeU32(v); }, 1);
+            writeU30(oneToZero(_abc.doubles.size()));
+            writeTable(
+                _abc.doubles, [this](auto v) { writeD64(v); }, 1);
+            writeU30(oneToZero(_abc.strings.size()));
+            writeTable(
+                _abc.strings, [this](auto v) { writeString(v); }, 1);
+            writeU30(oneToZero(_abc.namespaces.size()));
+            writeTable(
+                _abc.namespaces, [this](auto v) { writeNamespace(v); }, 1);
+            writeU30(oneToZero(_abc.namespaceSets.size()));
+            writeTable(
+                _abc.namespaceSets, [this](auto v) { writeNamespaceSet(v); }, 1);
+            writeU30(oneToZero(_abc.multinames.size()));
+            writeTable(
+                _abc.multinames, [this](auto v) { writeMultiname(v); }, 1);
+
+            writeU30(_abc.methods.size());
+            writeTable(_abc.methods, [this](auto v) { writeMethodInfo(v); });
+            writeU30(_abc.metadata.size());
+            writeTable(_abc.metadata, [this](auto v) { writeMetadata(v); });
+            writeU30(_abc.instances.size());
+            writeTable(_abc.instances, [this](auto v) { writeInstance(v); });
+            writeTable(_abc.classes, [this](auto v) { writeClass(v); });
+            writeU30(_abc.scripts.size());
+            writeTable(_abc.scripts, [this](auto v) { writeScript(v); });
+            writeU30(_abc.bodies.size());
+            writeTable(_abc.bodies, [this](auto v) { writeMethodBody(v); });
+
+            assert(_abc.classes.size() == _abc.instances.size());
+
+            buf.resize(pos);
+        }
+
+        void writeU8(uint8_t v)
+        {
+            if (pos == buf.size())
+                buf.resize(buf.size() * 2);
+            buf[pos++] = v;
+        }
+
+        void writeU16(uint16_t v)
+        {
+            writeU8(v & 0xFF);
+            writeU8((uint8_t)(v >> 8));
+        }
+
+        void writeS24(int32_t v)
+        {
+            writeU8(v & 0xFF);
+            writeU8((uint8_t)(v >> 8));
+            writeU8((uint8_t)(v >> 16));
+        }
+
+        void writeU32(uint64_t v)
+        {
+            if (v < 128)
+            {
+                writeU8((uint8_t)(v));
+            }
+            else if (v < 16384)
+            {
+                writeU8((uint8_t)((v & 0x7F) | 0x80));
+                writeU8((uint8_t)((v >> 7) & 0x7F));
+            }
+            else if (v < 2097152)
+            {
+                writeU8((uint8_t)((v & 0x7F) | 0x80));
+                writeU8((uint8_t)((v >> 7) | 0x80));
+                writeU8((uint8_t)((v >> 14) & 0x7F));
+            }
+            else if (v < 268435456)
+            {
+                writeU8((uint8_t)((v & 0x7F) | 0x80));
+                writeU8((uint8_t)(v >> 7 | 0x80));
+                writeU8((uint8_t)(v >> 14 | 0x80));
+                writeU8((uint8_t)((v >> 21) & 0x7F));
+            }
+            else
+            {
+                writeU8((uint8_t)((v & 0x7F) | 0x80));
+                writeU8((uint8_t)(v >> 7 | 0x80));
+                writeU8((uint8_t)(v >> 14 | 0x80));
+                writeU8((uint8_t)(v >> 21 | 0x80));
+                writeU8((uint8_t)((v >> 28) & 0x0F));
+            }
+        }
+
+        void writeS32(int64_t v) { writeU32(v); }
+
+        void writeU30(uint64_t v)
+        {
+            if (v >= 0x40'00'00'00)
+                throw StringException("U30 out of range");
+            writeU32(v);
+        }
+
+        void writeExact(const void* data, size_t len)
+        {
+            while (pos + len > buf.size())
+            {
+                buf.resize(buf.size() * 2);
+            }
+            memcpy(buf.data() + pos, data, len);
+            pos += len;
+        }
+
+        void writeD64(double v)
+        {
+            static_assert(std::numeric_limits<double>::is_iec559);
+            static_assert(std::endian::native == std::endian::little);
+            writeExact(&v, 8);
+        }
+
+        void writeString(std::string_view v)
+        {
+            writeU30(v.size());
+            writeExact(v.data(), v.size());
+        }
+
+        void writeBytes(const std::vector<uint8_t>& v)
+        {
+            writeU30(v.size());
+            writeExact(v.data(), v.size());
+        }
+
+        void writeNamespace(const Namespace& v)
+        {
+            writeU8((uint8_t)v.kind);
+            writeU30(v.name);
+        }
+
+        void writeNamespaceSet(const std::vector<int32_t> v)
+        {
+            writeU30(v.size());
+            writeTable(v, [this](auto v) { writeU30(v); });
+        }
+
+        void writeMultiname(const Multiname& v)
+        {
+            writeU8((uint8_t)v.kind);
+            switch (v.kind)
+            {
+                case ABCType::QName:
+                case ABCType::QNameA:
+                    writeU30(v.qname().ns);
+                    writeU30(v.qname().name);
+                    break;
+                case ABCType::RTQName:
+                case ABCType::RTQNameA:
+                    writeU30(v.rtqname().name);
+                    break;
+                case ABCType::RTQNameL:
+                case ABCType::RTQNameLA:
+                    break;
+                case ABCType::Multiname:
+                case ABCType::MultinameA:
+                    writeU30(v.multiname().name);
+                    writeU30(v.multiname().nsSet);
+                    break;
+                case ABCType::MultinameL:
+                case ABCType::MultinameLA:
+                    writeU30(v.multinamel().nsSet);
+                    break;
+                case ABCType::TypeName:
+                    writeU30(v.Typename().name);
+                    writeU30(v.Typename().params.size());
+                    writeTable(v.Typename().params, [this](auto v) { writeU30(v); });
+                    break;
+                default:
+                    throw StringException("Unknown multiname kind");
+            }
+        }
+
+        void writeMethodInfo(const MethodInfo& v)
+        {
+            writeU30(v.paramTypes.size());
+            writeU30(v.returnType);
+            for (const auto& value : v.paramTypes)
+            {
+                writeU30(value);
+            }
+            writeU30(v.name);
+            writeU8(v.flags);
+            if (v.flags & (uint8_t)MethodFlags::HAS_OPTIONAL)
+            {
+                writeU30(v.options.size());
+                writeTable(v.options, [this](auto v) { writeOptionDetail(v); });
+            }
+            if (v.flags & (uint8_t)MethodFlags::HAS_PARAM_NAMES)
+            {
+                assert(v.paramNames.size() == v.paramTypes.size());
+                writeTable(v.paramNames, [this](auto v) { writeU30(v); });
+            }
+        }
+
+        void writeOptionDetail(const OptionDetail& v)
+        {
+            writeU30(v.value);
+            writeU8((uint8_t)v.kind);
+        }
+
+        void writeMetadata(const Metadata& v)
+        {
+            writeU30(v.name);
+            writeU30(v.data.size());
+            for (const auto& val : v.data)
+            {
+                writeU30(val.first);
+                writeU30(val.second);
+            }
+        }
+
+        void writeInstance(const Instance& v)
+        {
+            writeU30(v.name);
+            writeU30(v.superName);
+            writeU8(v.flags);
+            if (v.flags & (uint8_t)InstanceFlags::ProtectedNs)
+            {
+                writeU30(v.protectedNs);
+            }
+            writeU30(v.interfaces.size());
+            writeTable(v.interfaces, [this](auto v) { writeU30(v); });
+            writeU30(v.iinit);
+            writeU30(v.traits.size());
+            writeTable(v.traits, [this](auto v) { writeTrait(v); });
+        }
+
+        void writeTrait(const TraitsInfo& v)
+        {
+            writeU30(v.name);
+            writeU8(v.kindAttr);
+            switch (v.kind())
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    writeU30(v.Slot.slotId);
+                    writeU30(v.Slot.typeName);
+                    writeU30(v.Slot.vindex);
+                    if (v.Slot.vindex != 0)
+                        writeU8((uint8_t)v.Slot.vkind);
+                    break;
+                case TraitKind::Class:
+                    writeU30(v.Class.slotId);
+                    writeU30(v.Class.classi);
+                    break;
+                case TraitKind::Function:
+                    writeU30(v.Function.slotId);
+                    writeU30(v.Function.functioni);
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    writeU30(v.Method.dispId);
+                    writeU30(v.Method.method);
+                    break;
+                default:
+                    throw StringException("Unknown trait type");
+            }
+
+            if (v.attr() & (uint8_t)TraitAttribute::Metadata)
+            {
+                writeU30(v.metadata.size());
+                writeTable(v.metadata, [this](auto v) { writeU30(v); });
+            }
+        }
+
+        void writeClass(const Class& v)
+        {
+            writeU30(v.cinit);
+            writeU30(v.traits.size());
+            writeTable(v.traits, [this](auto v) { writeTrait(v); });
+        }
+
+        void writeScript(const Script& v)
+        {
+            writeU30(v.sinit);
+            writeU30(v.traits.size());
+            writeTable(v.traits, [this](auto v) { writeTrait(v); });
+        }
+
+        void writeMethodBody(const MethodBody& v)
+        {
+            writeU30(v.method);
+            writeU30(v.maxStack);
+            writeU30(v.localCount);
+            writeU30(v.initScopeDepth);
+            writeU30(v.maxScopeDepth);
+
+            std::vector<size_t> instructionOffsets(v.instructions.size() + 1);
+
+            auto resolveLabel = [&](const Label& label) -> ptrdiff_t {
+                return instructionOffsets[label.index] + label.offset;
+            };
+
+            {
+                // Temporarily store global buffer
+                std::vector<uint8_t> globalBuf = std::move(buf);
+                size_t globalPos               = pos;
+                buf                            = {};
+                buf.resize(1024 * 16);
+                pos = 0;
+
+                struct Fixup
+                {
+                    Label target;
+                    size_t pos, base;
+                };
+
+                std::vector<Fixup> fixups;
+
+                for (size_t ii = 0; ii < v.instructions.size(); ii++)
+                {
+                    const auto& instruction = v.instructions[ii];
+
+                    size_t instructionOffset = pos;
+                    instructionOffsets[ii]   = instructionOffset;
+
+                    writeU8((uint8_t)instruction.opcode);
+
+                    if (instruction.arguments.size() !=
+                        OPCode_Info[(uint8_t)instruction.opcode].second.size())
+                        throw StringException("Mismatching number of arguments");
+
+                    for (size_t i = 0; i < instruction.arguments.size(); i++)
+                    {
+                        switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                        {
+                            case OPCodeArgumentType::Unknown:
+                                throw StringException(
+                                    std::string("Don't know how to encode OP_") +
+                                    OPCode_Info[(uint8_t)instruction.opcode].first);
+
+                            case OPCodeArgumentType::ByteLiteral:
+                                writeU8(instruction.arguments[i].bytev());
+                                break;
+                            case OPCodeArgumentType::UByteLiteral:
+                                writeU8(instruction.arguments[i].ubytev());
+                                break;
+                            case OPCodeArgumentType::IntLiteral:
+                                writeS32(instruction.arguments[i].intv());
+                                break;
+                            case OPCodeArgumentType::UIntLiteral:
+                                writeU32(instruction.arguments[i].uintv());
+                                break;
+
+                            case OPCodeArgumentType::Int:
+                            case OPCodeArgumentType::UInt:
+                            case OPCodeArgumentType::Double:
+                            case OPCodeArgumentType::String:
+                            case OPCodeArgumentType::Namespace:
+                            case OPCodeArgumentType::Multiname:
+                            case OPCodeArgumentType::Class:
+                            case OPCodeArgumentType::Method:
+                                writeU30(instruction.arguments[i].index());
+                                break;
+
+                            case OPCodeArgumentType::JumpTarget:
+                                fixups.emplace_back(
+                                    instruction.arguments[i].jumpTarget(), pos, pos + 3);
+                                writeS24(0);
+                                break;
+
+                            case OPCodeArgumentType::SwitchDefaultTarget:
+                                fixups.emplace_back(
+                                    instruction.arguments[i].jumpTarget(), pos, instructionOffset);
+                                writeS24(0);
+                                break;
+
+                            case OPCodeArgumentType::SwitchTargets:
+                                if (instruction.arguments[i].switchTargets().size() < 1)
+                                    throw StringException("Too few switch cases");
+                                writeU30(instruction.arguments[i].switchTargets().size() - 1);
+                                for (const auto& target : instruction.arguments[i].switchTargets())
+                                {
+                                    fixups.emplace_back(target, pos, instructionOffset);
+                                    writeS24(0);
+                                }
+                                break;
+                        }
+                    }
+                }
+
+                buf.resize(pos);
+                instructionOffsets[v.instructions.size()] = pos;
+
+                for (const auto& fixup : fixups)
+                {
+                    pos = fixup.pos;
+                    writeS24((int32_t)((ptrdiff_t)(resolveLabel(fixup.target) - fixup.base)));
+                }
+
+                std::vector<uint8_t> code = std::move(buf);
+                // Restore global buffer
+                buf = std::move(globalBuf);
+                pos = globalPos;
+
+                writeBytes(code);
+            }
+
+            writeU30(v.exceptions.size());
+            for (const auto& exception : v.exceptions)
+            {
+                ExceptionInfo write         = exception;
+                write.from.absoluteOffset   = resolveLabel(exception.from);
+                write.to.absoluteOffset     = resolveLabel(exception.to);
+                write.target.absoluteOffset = resolveLabel(exception.target);
+                writeExceptionInfo(write);
+            }
+            writeU30(v.traits.size());
+            writeTable(v.traits, [this](auto v) { writeTrait(v); });
+        }
+
+        void writeExceptionInfo(const ExceptionInfo& v)
+        {
+            writeU30(v.from.absoluteOffset);
+            writeU30(v.to.absoluteOffset);
+            writeU30(v.target.absoluteOffset);
+            writeU30(v.excType);
+            writeU30(v.varName);
+        }
+    };
+
+}
diff --git a/Native/BytecodeEditor/include/ABC/Class.hpp b/Native/BytecodeEditor/include/ABC/Class.hpp
new file mode 100644
index 0000000..360dfff
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Class.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ABC/TraitsInfo.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct Class
+    {
+        uint32_t cinit = 0;
+        std::vector<TraitsInfo> traits;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Error.hpp b/Native/BytecodeEditor/include/ABC/Error.hpp
new file mode 100644
index 0000000..a20b009
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Error.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "ABC/Label.hpp"
+#include <string>
+
+namespace ABC
+{
+    struct Error
+    {
+        Label loc;
+        std::string message;
+
+        std::strong_ordering operator<=>(const Error&) const = default;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/ExceptionInfo.hpp b/Native/BytecodeEditor/include/ABC/ExceptionInfo.hpp
new file mode 100644
index 0000000..036ad68
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/ExceptionInfo.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ABC/Label.hpp"
+#include <stdint.h>
+
+namespace ABC
+{
+    struct ExceptionInfo
+    {
+        Label from, to, target;
+        uint32_t excType = 0;
+        uint32_t varName = 0;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Instance.hpp b/Native/BytecodeEditor/include/ABC/Instance.hpp
new file mode 100644
index 0000000..f860554
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Instance.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ABC/TraitsInfo.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct Instance
+    {
+        uint32_t name        = 0;
+        uint32_t superName   = 0;
+        uint32_t protectedNs = 0;
+        std::vector<uint32_t> interfaces;
+        uint32_t iinit = 0;
+        std::vector<TraitsInfo> traits;
+        uint8_t flags = 0;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Instruction.hpp b/Native/BytecodeEditor/include/ABC/Instruction.hpp
new file mode 100644
index 0000000..07514b3
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Instruction.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "ABC/Label.hpp"
+#include "enums/OPCode.hpp"
+#include <stdint.h>
+#include <variant>
+#include <vector>
+
+namespace ABC
+{
+    struct Instruction
+    {
+        OPCode opcode = OPCode::OP_raw;
+        struct Argument
+        {
+        private:
+            std::variant<std::monostate, int8_t, uint8_t, int64_t, uint64_t, uint32_t, Label,
+                std::vector<Label>>
+                data;
+
+        public:
+            [[nodiscard]] int8_t& bytev() { return std::get<int8_t>(data); }
+            [[nodiscard]] const int8_t& bytev() const { return std::get<int8_t>(data); }
+            void bytev(int8_t bytev) { data = bytev; }
+            [[nodiscard]] uint8_t& ubytev() { return std::get<uint8_t>(data); }
+            [[nodiscard]] const uint8_t& ubytev() const { return std::get<uint8_t>(data); }
+            void ubytev(uint8_t ubytev) { data = ubytev; }
+            [[nodiscard]] int64_t& intv() { return std::get<int64_t>(data); }
+            [[nodiscard]] const int64_t& intv() const { return std::get<int64_t>(data); }
+            void intv(int64_t intv) { data = intv; }
+            [[nodiscard]] uint64_t& uintv() { return std::get<uint64_t>(data); }
+            [[nodiscard]] const uint64_t& uintv() const { return std::get<uint64_t>(data); }
+            void uintv(uint64_t uintv) { data = uintv; }
+            [[nodiscard]] uint32_t& index() { return std::get<uint32_t>(data); }
+            [[nodiscard]] const uint32_t& index() const { return std::get<uint32_t>(data); }
+            void index(uint32_t index) { data = index; }
+
+            [[nodiscard]] Label& jumpTarget() { return std::get<Label>(data); }
+            [[nodiscard]] const Label& jumpTarget() const { return std::get<Label>(data); }
+            void jumpTarget(Label jumpTarget) { data = jumpTarget; }
+            [[nodiscard]] std::vector<Label>& switchTargets()
+            {
+                return std::get<std::vector<Label>>(data);
+            }
+            [[nodiscard]] const std::vector<Label>& switchTargets() const
+            {
+                return std::get<std::vector<Label>>(data);
+            }
+            void switchTargets(std::vector<Label>&& switchTargets)
+            {
+                data = std::move(switchTargets);
+            }
+        };
+        std::vector<Argument> arguments;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Label.hpp b/Native/BytecodeEditor/include/ABC/Label.hpp
new file mode 100644
index 0000000..c959025
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Label.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace ABC
+{
+    struct Label
+    {
+        uint32_t index           = 0;
+        int32_t offset           = 0;
+        ptrdiff_t absoluteOffset = 0;
+
+        std::strong_ordering operator<=>(const Label&) const = default;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Metadata.hpp b/Native/BytecodeEditor/include/ABC/Metadata.hpp
new file mode 100644
index 0000000..adb5621
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Metadata.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct Metadata
+    {
+        uint32_t name = 0;
+        std::vector<std::pair<uint32_t, uint32_t>> data;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/MethodBody.hpp b/Native/BytecodeEditor/include/ABC/MethodBody.hpp
new file mode 100644
index 0000000..25a40c7
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/MethodBody.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ABC/Error.hpp"
+#include "ABC/ExceptionInfo.hpp"
+#include "ABC/Instruction.hpp"
+#include "ABC/TraitsInfo.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct MethodBody
+    {
+        uint32_t method = 0, maxStack = 0, localCount = 0, initScopeDepth = 0, maxScopeDepth = 0;
+        std::vector<Instruction> instructions;
+        std::vector<ExceptionInfo> exceptions;
+        std::vector<TraitsInfo> traits;
+        std::vector<Error> errors;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/MethodInfo.hpp b/Native/BytecodeEditor/include/ABC/MethodInfo.hpp
new file mode 100644
index 0000000..671e5e0
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/MethodInfo.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "ABC/OptionDetail.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct MethodInfo
+    {
+        std::vector<uint32_t> paramTypes;
+        uint32_t returnType = 0;
+        uint32_t name       = 0;
+        std::vector<OptionDetail> options;
+        std::vector<uint32_t> paramNames;
+        uint8_t flags = 0;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Multiname.hpp b/Native/BytecodeEditor/include/ABC/Multiname.hpp
new file mode 100644
index 0000000..27dd175
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Multiname.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "enums/ABCType.hpp"
+#include <stdint.h>
+#include <variant>
+#include <vector>
+
+namespace ABC
+{
+    struct Multiname
+    {
+        struct _QName
+        {
+            uint32_t ns, name;
+        };
+        struct _RTQName
+        {
+            uint32_t name;
+        };
+        struct _RTQNameL
+        {
+        };
+        struct _Multiname
+        {
+            uint32_t name, nsSet;
+        };
+        struct _MultinameL
+        {
+            uint32_t nsSet;
+        };
+        struct _Typename
+        {
+            uint32_t name;
+            std::vector<uint32_t> params;
+        };
+
+        ABCType kind = ABCType::Void;
+
+        [[nodiscard]] const _QName& qname() const { return std::get<_QName>(data); }
+        void qname(const _QName& v) { data = v; }
+        [[nodiscard]] const _RTQName& rtqname() const { return std::get<_RTQName>(data); }
+        void rtqname(const _RTQName& v) { data = v; }
+        [[nodiscard]] const _RTQNameL& rtqnamel() const { return std::get<_RTQNameL>(data); }
+        void rtqnamel(const _RTQNameL& v) { data = v; }
+        [[nodiscard]] const _Multiname& multiname() const { return std::get<_Multiname>(data); }
+        void multiname(const _Multiname& v) { data = v; }
+        [[nodiscard]] const _MultinameL& multinamel() const { return std::get<_MultinameL>(data); }
+        void multinamel(const _MultinameL& v) { data = v; }
+        [[nodiscard]] const _Typename& Typename() const { return std::get<_Typename>(data); }
+        void Typename(const _Typename& v) { data = v; }
+        void Typename(_Typename&& v) { data = std::move(v); }
+
+    private:
+        std::variant<std::monostate, _QName, _RTQName, _RTQNameL, _Multiname, _MultinameL,
+            _Typename>
+            data;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Namespace.hpp b/Native/BytecodeEditor/include/ABC/Namespace.hpp
new file mode 100644
index 0000000..b31c650
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Namespace.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "enums/ABCType.hpp"
+#include <stdint.h>
+
+namespace ABC
+{
+    struct Namespace
+    {
+        ABCType kind;
+        uint32_t name = 0;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/OptionDetail.hpp b/Native/BytecodeEditor/include/ABC/OptionDetail.hpp
new file mode 100644
index 0000000..b1d06a5
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/OptionDetail.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "enums/ABCType.hpp"
+#include <stdint.h>
+
+namespace ABC
+{
+    struct OptionDetail
+    {
+        uint32_t value = 0;
+        ABCType kind;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/Script.hpp b/Native/BytecodeEditor/include/ABC/Script.hpp
new file mode 100644
index 0000000..204bed7
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/Script.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ABC/TraitsInfo.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct Script
+    {
+        uint32_t sinit = 0;
+        std::vector<TraitsInfo> traits;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ABC/TraitsInfo.hpp b/Native/BytecodeEditor/include/ABC/TraitsInfo.hpp
new file mode 100644
index 0000000..5643c49
--- /dev/null
+++ b/Native/BytecodeEditor/include/ABC/TraitsInfo.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "enums/ABCType.hpp"
+#include "enums/TraitKind.hpp"
+#include <stdint.h>
+#include <vector>
+
+namespace ABC
+{
+    struct TraitsInfo
+    {
+        uint32_t name    = 0;
+        uint8_t kindAttr = 0;
+        union
+        {
+            struct
+            {
+                uint32_t slotId, typeName, vindex;
+                ABCType vkind;
+            } Slot;
+            struct
+            {
+                uint32_t slotId, classi;
+            } Class;
+            struct
+            {
+                uint32_t slotId, functioni;
+            } Function;
+            struct
+            {
+                uint32_t dispId, method;
+            } Method;
+        };
+        std::vector<uint32_t> metadata;
+
+        [[nodiscard]] TraitKind kind() const { return TraitKind(kindAttr & 0xF); }
+        void kind(TraitKind k) { kindAttr = (kindAttr & 0xF0) | uint8_t(k); }
+        [[nodiscard]] uint8_t attr() const { return kindAttr >> 4; }
+        void attr(uint8_t a) { kindAttr = (kindAttr & 0xF) | uint8_t(a << 4); }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ANEBytecodeEditor.hpp b/Native/BytecodeEditor/include/ANEBytecodeEditor.hpp
new file mode 100644
index 0000000..c174c13
--- /dev/null
+++ b/Native/BytecodeEditor/include/ANEBytecodeEditor.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <FlashRuntimeExtensions.h>
+
+#if defined(WIN32)
+#define EXPORT __declspec(dllexport)
+#else
+// Symbols tagged with EXPORT are externally visible.
+// Must use the -fvisibility=hidden gcc option.
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+void ContextInitializer(void* extData, const uint8_t* ctxType, FREContext ctx,
+    uint32_t* numFunctions, const FRENamedFunction** functions);
+void ContextFinalizer(FREContext ctx);
+
+extern "C" {
+EXPORT void ExtInitializerANEBytecodeEditor(void** extDataToSet,
+    FREContextInitializer* ctxInitializerToSet, FREContextFinalizer* ctxFinalizerToSet);
+EXPORT void ExtFinalizerANEBytecodeEditor(void* extData);
+}
diff --git a/Native/BytecodeEditor/include/ASASM/ASProgram.hpp b/Native/BytecodeEditor/include/ASASM/ASProgram.hpp
new file mode 100644
index 0000000..366b592
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/ASProgram.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "ABC/ABCFile.hpp"
+#include "ASASM/Class.hpp"
+#include "ASASM/Method.hpp"
+#include "ASASM/Script.hpp"
+#include "utils/StringException.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <vector>
+
+class Assembler;
+
+namespace ASASM
+{
+    class ASProgram
+    {
+        friend class ::Assembler;
+
+    private:
+        ASProgram() : minorVersion(16), majorVersion(46) {}
+
+    public:
+        uint16_t minorVersion, majorVersion;
+
+        std::vector<Script> scripts;
+        // Pointers to the below
+        std::vector<std::shared_ptr<Class>> orphanClasses;
+        std::vector<std::shared_ptr<Method>> orphanMethods;
+
+        static ASProgram fromABC(const ABC::ABCFile& abc);
+        ABC::ABCFile toABC();
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/ASTraitsVisitor.hpp b/Native/BytecodeEditor/include/ASASM/ASTraitsVisitor.hpp
new file mode 100644
index 0000000..7e5e2e6
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/ASTraitsVisitor.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "ASASM/ASProgram.hpp"
+
+namespace ASASM
+{
+    class ASTraitsVisitor
+    {
+    protected:
+        const ASASM::ASProgram& as;
+
+    public:
+        explicit ASTraitsVisitor(const ASProgram& as) noexcept : as(as) {}
+        virtual ~ASTraitsVisitor() = default;
+
+        virtual void run()
+        {
+            for (const auto& v : as.scripts)
+            {
+                visitTraits(v.traits);
+            }
+        }
+
+        void visitTraits(const std::vector<Trait>& traits)
+        {
+            for (const auto& trait : traits)
+            {
+                visitTrait(trait);
+            }
+        }
+
+        virtual void visitTrait(const Trait& trait)
+        {
+            switch (trait.kind)
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    break;
+                case TraitKind::Class:
+                    visitTraits(trait.vClass().vclass->traits);
+                    visitTraits(trait.vClass().vclass->instance.traits);
+                    break;
+                case TraitKind::Function:
+                    if (trait.vFunction().vfunction->vbody)
+                        visitTraits(trait.vFunction().vfunction->vbody->traits);
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    if (trait.vMethod().vmethod->vbody)
+                        visitTraits(trait.vMethod().vmethod->vbody->traits);
+                    break;
+                default:
+                    throw StringException("Unknown trait kind");
+            }
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/AStoABC.hpp b/Native/BytecodeEditor/include/ASASM/AStoABC.hpp
new file mode 100644
index 0000000..2cb495d
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/AStoABC.hpp
@@ -0,0 +1,753 @@
+#pragma once
+
+#include "ABC/ABCFile.hpp"
+#include "ASASM/ASTraitsVisitor.hpp"
+#include "ASASM/Class.hpp"
+#include "ASASM/Metadata.hpp"
+#include "ASASM/Method.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "utils/ValuePool.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace ASASM
+{
+    class AStoABC : public ASTraitsVisitor
+    {
+    public:
+        ValuePool<int64_t> ints;
+        ValuePool<uint64_t> uints;
+        ValuePool<double> doubles;
+        ValuePool<std::string> strings;
+        ValuePool<ASASM::Namespace> namespaces;
+        ValuePool<std::vector<ASASM::Namespace>> namespaceSets;
+        ValuePool<ASASM::Multiname> multinames;
+        ValuePool<ASASM::Metadata, false> metadatas;
+        ValuePool<std::shared_ptr<ASASM::Class>, false> classes;
+        ValuePool<std::shared_ptr<ASASM::Method>, false> methods;
+
+        ABC::ABCFile abc;
+
+        void visitInt(int64_t v) { ints.add(v); }
+        void visitUint(uint64_t v) { uints.add(v); }
+        void visitDouble(double v) { doubles.add(v); }
+        void visitString(const std::string& v) { strings.add(v); }
+
+        void visitNamespace(const Namespace& ns)
+        {
+            if (namespaces.add(ns))
+            {
+                if (ns.kind != ABCType::Void)
+                {
+                    visitString(ns.name);
+                }
+            }
+        }
+
+        void visitNamespaceSet(const std::vector<ASASM::Namespace>& nsSet)
+        {
+            if (namespaceSets.add(nsSet))
+            {
+                for (const auto& ns : nsSet)
+                {
+                    visitNamespace(ns);
+                }
+            }
+        }
+
+        void visitMultiname(const ASASM::Multiname& multiname)
+        {
+            if (multinames.notAdded(multiname))
+            {
+                if (multiname.kind != ABCType::Void)
+                {
+                    switch (multiname.kind)
+                    {
+                        case ABCType::QName:
+                        case ABCType::QNameA:
+                            visitNamespace(multiname.qname().ns);
+                            visitString(multiname.qname().name);
+                            break;
+                        case ABCType::RTQName:
+                        case ABCType::RTQNameA:
+                            visitString(multiname.rtqname().name);
+                            break;
+                        case ABCType::RTQNameL:
+                        case ABCType::RTQNameLA:
+                            break;
+                        case ABCType::Multiname:
+                        case ABCType::MultinameA:
+                            visitString(multiname.multiname().name);
+                            visitNamespaceSet(multiname.multiname().nsSet);
+                            break;
+                        case ABCType::MultinameL:
+                        case ABCType::MultinameLA:
+                            visitNamespaceSet(multiname.multinamel().nsSet);
+                            break;
+                        case ABCType::TypeName:
+                            visitMultiname(multiname.Typename().name());
+                            for (const auto& param : multiname.Typename().params())
+                            {
+                                visitMultiname(param);
+                            }
+                            break;
+                        default:
+                            throw StringException("Unknown multiname kind");
+                    }
+                }
+
+                bool unrecursiveMultiname = multinames.add(multiname);
+                assert(unrecursiveMultiname);
+            }
+        }
+
+        void visitScript(const ASASM::Script& script)
+        {
+            visitTraits(script.traits);
+            if (script.sinit)
+            {
+                visitMethod(script.sinit);
+            }
+        }
+
+        void visitTrait(const ASASM::Trait& trait)
+        {
+            visitMultiname(trait.name);
+            switch (trait.kind)
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    visitMultiname(trait.vSlot().typeName);
+                    visitValue(trait.vSlot().value);
+                    break;
+                case TraitKind::Class:
+                    if (trait.vClass().vclass)
+                    {
+                        visitClass(trait.vClass().vclass);
+                    }
+                    break;
+                case TraitKind::Function:
+                    if (trait.vFunction().vfunction)
+                    {
+                        visitMethod(trait.vFunction().vfunction);
+                    }
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    if (trait.vMethod().vmethod)
+                    {
+                        visitMethod(trait.vMethod().vmethod);
+                    }
+                    break;
+                default:
+                    throw StringException("Unknown trait kind");
+            }
+            for (const auto& md : trait.metadata)
+            {
+                visitMetadata(md);
+            }
+        }
+
+        void visitMetadata(const ASASM::Metadata& metadata)
+        {
+            if (metadatas.add(metadata))
+            {
+                if (!metadata.data.empty())
+                {
+                    visitString(metadata.name);
+                    for (const auto& md : metadata.data)
+                    {
+                        visitString(md.first);
+                        visitString(md.second);
+                    }
+                }
+            }
+        }
+
+        void visitValue(const ASASM::Value& value)
+        {
+            switch (value.vkind)
+            {
+                case ABCType::Integer:
+                    visitInt(value.vint());
+                    break;
+                case ABCType::UInteger:
+                    visitUint(value.vuint());
+                    break;
+                case ABCType::Double:
+                    visitDouble(value.vdouble());
+                    break;
+                case ABCType::Utf8:
+                    visitString(value.vstring());
+                    break;
+                case ABCType::Namespace:
+                case ABCType::PackageNamespace:
+                case ABCType::PackageInternalNs:
+                case ABCType::ProtectedNamespace:
+                case ABCType::ExplicitNamespace:
+                case ABCType::StaticProtectedNs:
+                case ABCType::PrivateNamespace:
+                    visitNamespace(value.vnamespace());
+                    break;
+                case ABCType::True:
+                case ABCType::False:
+                case ABCType::Null:
+                case ABCType::Undefined:
+                    break;
+                default:
+                    throw StringException("Unknown value type");
+            }
+        }
+
+        void visitClass(const std::shared_ptr<ASASM::Class>& vclass)
+        {
+            if (classes.add(vclass))
+            {
+                if (vclass)
+                {
+                    visitMethod(vclass->cinit);
+                    visitTraits(vclass->traits);
+                    visitInstance(vclass->instance);
+                }
+            }
+        }
+
+        void visitMethod(const std::shared_ptr<ASASM::Method>& method)
+        {
+            if (methods.add(method))
+            {
+                if (method)
+                {
+                    for (const auto& t : method->paramTypes)
+                    {
+                        visitMultiname(t);
+                    }
+                    visitMultiname(method->returnType);
+                    visitString(method->name);
+                    for (const auto& v : method->options)
+                    {
+                        visitValue(v);
+                    }
+                    for (const auto& n : method->paramNames)
+                    {
+                        visitString(n);
+                    }
+
+                    if (method->vbody)
+                    {
+                        visitMethodBody(*method->vbody);
+                    }
+                }
+            }
+        }
+
+        void visitMethodBody(const ASASM::MethodBody& body)
+        {
+            if (body.method.lock() != nullptr)
+            {
+                for (const auto& instruction : body.instructions)
+                {
+                    for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size();
+                         i++)
+                    {
+                        switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                        {
+                            case OPCodeArgumentType::Unknown:
+                                throw StringException(
+                                    "Don't know how to visit OP_" +
+                                    std::string(OPCode_Info[(uint8_t)instruction.opcode].first));
+
+                            case OPCodeArgumentType::ByteLiteral:
+                            case OPCodeArgumentType::UByteLiteral:
+                            case OPCodeArgumentType::IntLiteral:
+                            case OPCodeArgumentType::UIntLiteral:
+                                break;
+
+                            case OPCodeArgumentType::Int:
+                                visitInt(instruction.arguments[i].intv());
+                                break;
+                            case OPCodeArgumentType::UInt:
+                                visitUint(instruction.arguments[i].uintv());
+                                break;
+                            case OPCodeArgumentType::Double:
+                                visitDouble(instruction.arguments[i].doublev());
+                                break;
+                            case OPCodeArgumentType::String:
+                                visitString(instruction.arguments[i].stringv());
+                                break;
+                            case OPCodeArgumentType::Namespace:
+                                visitNamespace(instruction.arguments[i].namespacev());
+                                break;
+                            case OPCodeArgumentType::Multiname:
+                                visitMultiname(instruction.arguments[i].multinamev());
+                                break;
+                            case OPCodeArgumentType::Class:
+                                visitClass(instruction.arguments[i].classv());
+                                break;
+                            case OPCodeArgumentType::Method:
+                                visitMethod(instruction.arguments[i].methodv());
+                                break;
+
+                            case OPCodeArgumentType::JumpTarget:
+                            case OPCodeArgumentType::SwitchDefaultTarget:
+                            case OPCodeArgumentType::SwitchTargets:
+                                break;
+                            default:
+                                assert(false);
+                        }
+                    }
+                }
+
+                for (const auto& exception : body.exceptions)
+                {
+                    visitMultiname(exception.excType);
+                    visitMultiname(exception.varName);
+                }
+
+                visitMethod(body.method.lock());
+                visitTraits(body.traits);
+            }
+        }
+
+        void visitInstance(const ASASM::Instance& instance)
+        {
+            visitMultiname(instance.name);
+            visitMultiname(instance.superName);
+            visitNamespace(instance.protectedNs);
+            for (const auto& intf : instance.interfaces)
+            {
+                visitMultiname(intf);
+            }
+            visitMethod(instance.iinit);
+            visitTraits(instance.traits);
+        }
+
+        void run() override
+        {
+            for (const auto& script : as.scripts)
+            {
+                visitScript(script);
+            }
+            for (const auto& vclass : as.orphanClasses)
+            {
+                visitClass(vclass);
+            }
+            for (const auto& vmethod : as.orphanMethods)
+            {
+                visitMethod(vmethod);
+            }
+        }
+
+        uint32_t getValueIndex(const ASASM::Value& value)
+        {
+            switch (value.vkind)
+            {
+                case ABCType::Integer:
+                    return ints.get(value.vint());
+                case ABCType::UInteger:
+                    return uints.get(value.vuint());
+                case ABCType::Double:
+                    return doubles.get(value.vdouble());
+                case ABCType::Utf8:
+                    return strings.get(value.vstring());
+                case ABCType::Namespace:
+                case ABCType::PackageNamespace:
+                case ABCType::PackageInternalNs:
+                case ABCType::ProtectedNamespace:
+                case ABCType::ExplicitNamespace:
+                case ABCType::StaticProtectedNs:
+                case ABCType::PrivateNamespace:
+                    return namespaces.get(value.vnamespace());
+                case ABCType::True:
+                case ABCType::False:
+                case ABCType::Null:
+                case ABCType::Undefined:
+                    return (uint32_t)value.vkind; // must be non-zero for True/False/Null
+                default:
+                    throw StringException("Unknown type");
+            }
+        }
+
+        void registerClassDependencies()
+        {
+            std::map<ASASM::Multiname, std::shared_ptr<ASASM::Class>> classByName;
+
+            auto classObjects = classes.getPreliminaryValues();
+            for (const auto& c : classObjects)
+            {
+                classByName[c->instance.name] = c;
+            }
+
+            for (const auto& c : classObjects)
+            {
+                const auto depWork = [this, &c, &classByName](const ASASM::Multiname& dep) {
+                    if (dep.kind != ABCType::Void)
+                    {
+                        for (const auto& depName : dep.toQNames())
+                        {
+                            if (classByName.contains(depName))
+                            {
+                                classes.registerDependency(c, classByName[depName]);
+                            }
+                        }
+                    }
+                };
+
+                depWork(c->instance.superName);
+                for (const auto& intf : c->instance.interfaces)
+                {
+                    depWork(intf);
+                }
+            }
+        }
+
+        void registerMultinameDependencies()
+        {
+            for (const auto& m : multinames.getPreliminaryValues())
+            {
+                if (m.kind == ABCType::TypeName)
+                {
+                    multinames.registerDependency(m, m.Typename().name());
+                    for (const auto& t : m.Typename().params())
+                    {
+                        if (t.kind != ABCType::Void)
+                        {
+                            multinames.registerDependency(m, t);
+                        }
+                    }
+                }
+            }
+        }
+
+        explicit AStoABC(const ASProgram& as) : ASTraitsVisitor(as)
+        {
+            abc.minorVersion = as.minorVersion;
+            abc.majorVersion = as.majorVersion;
+
+            run();
+
+            registerClassDependencies();
+            registerMultinameDependencies();
+
+            ints.finalize();
+            uints.finalize();
+            doubles.finalize();
+            strings.finalize();
+            namespaces.finalize();
+            namespaceSets.finalize();
+            multinames.finalize();
+            metadatas.finalize();
+            classes.finalize();
+            methods.finalize();
+
+            abc.ints    = ints.values;
+            abc.uints   = uints.values;
+            abc.doubles = doubles.values;
+            abc.strings = strings.values;
+
+            abc.namespaces.reserve(namespaces.values.size());
+            for (size_t i = 1; i < namespaces.values.size(); i++)
+            {
+                abc.namespaces.emplace_back(
+                    namespaces.values[i].kind, strings.get(namespaces.values[i].name));
+            }
+
+            abc.namespaceSets.reserve(namespaceSets.values.size());
+            for (size_t i = 1; i < namespaceSets.values.size(); i++)
+            {
+                std::vector<int32_t>& nsSet = abc.namespaceSets.emplace_back(
+                    std::vector<int32_t>(namespaceSets.values[i].size()));
+                for (size_t j = 0; j < namespaceSets.values[i].size(); j++)
+                {
+                    nsSet[j] = namespaces.get(namespaceSets.values[i][j]);
+                }
+            }
+
+            abc.multinames.reserve(multinames.values.size());
+            for (size_t i = 1; i < multinames.values.size(); i++)
+            {
+                ABC::Multiname& multiname = abc.multinames.emplace_back();
+                multiname.kind            = multinames.values[i].kind;
+                switch (multinames.values[i].kind)
+                {
+                    case ABCType::QName:
+                    case ABCType::QNameA:
+                        multiname.qname({.ns = namespaces.get(multinames.values[i].qname().ns),
+                            .name            = strings.get(multinames.values[i].qname().name)});
+                        break;
+                    case ABCType::RTQName:
+                    case ABCType::RTQNameA:
+                        multiname.rtqname(
+                            {.name = strings.get(multinames.values[i].rtqname().name)});
+                        break;
+                    case ABCType::RTQNameL:
+                    case ABCType::RTQNameLA:
+                        multiname.rtqnamel({});
+                        break;
+                    case ABCType::Multiname:
+                    case ABCType::MultinameA:
+                        multiname.multiname({.name =
+                                                 strings.get(multinames.values[i].multiname().name),
+                            .nsSet = namespaceSets.get(multinames.values[i].multiname().nsSet)});
+                        break;
+                    case ABCType::MultinameL:
+                    case ABCType::MultinameLA:
+                        multiname.multinamel(
+                            {.nsSet = namespaceSets.get(multinames.values[i].multinamel().nsSet)});
+                        break;
+                    case ABCType::TypeName:
+                    {
+                        ABC::Multiname::_Typename tn = {
+                            .name   = multinames.get(multinames.values[i].Typename().name()),
+                            .params = std::vector<uint32_t>(
+                                multinames.values[i].Typename().params().size())};
+                        for (size_t j = 0; j < multinames.values[i].Typename().params().size(); j++)
+                        {
+                            tn.params[j] =
+                                multinames.get(multinames.values[i].Typename().params()[j]);
+                        }
+                        multiname.Typename(std::move(tn));
+                    }
+                    break;
+                    default:
+                        throw StringException("Unknown Multiname kind");
+                }
+            }
+
+            abc.metadata.reserve(metadatas.values.size());
+            for (size_t i = 0; i < metadatas.values.size(); i++)
+            {
+                ABC::Metadata& metadata = abc.metadata.emplace_back(
+                    strings.get(metadatas.values[i].name),
+                    std::vector<std::pair<uint32_t, uint32_t>>(metadatas.values[i].data.size()));
+                for (size_t j = 0; j < metadatas.values[i].data.size(); j++)
+                {
+                    metadata.data[j] = {strings.get(metadatas.values[i].data[j].first),
+                        strings.get(metadatas.values[i].data[j].second)};
+                }
+            }
+
+            std::vector<ASASM::MethodBody> bodies;
+
+            abc.methods.reserve(methods.values.size());
+            for (size_t i = 0; i < methods.values.size(); i++)
+            {
+                ABC::MethodInfo& info = abc.methods.emplace_back();
+
+                info.paramTypes.reserve(methods.values[i]->paramTypes.size());
+                for (const auto& paramType : methods.values[i]->paramTypes)
+                {
+                    info.paramTypes.emplace_back(multinames.get(paramType));
+                }
+                info.returnType = multinames.get(methods.values[i]->returnType);
+                info.name       = strings.get(methods.values[i]->name);
+                info.flags      = methods.values[i]->flags;
+                info.options.reserve(methods.values[i]->options.size());
+                for (const auto& option : methods.values[i]->options)
+                {
+                    info.options.emplace_back(getValueIndex(option), option.vkind);
+                }
+                info.paramNames.reserve(methods.values[i]->paramNames.size());
+                for (const auto& paramName : methods.values[i]->paramNames)
+                {
+                    info.paramNames.emplace_back(strings.get(paramName));
+                }
+
+                if (methods.values[i]->vbody)
+                {
+                    bodies.emplace_back(*methods.values[i]->vbody);
+                }
+            }
+
+            abc.instances.reserve(classes.values.size());
+            for (size_t i = 0; i < classes.values.size(); i++)
+            {
+                ABC::Instance& instance = abc.instances.emplace_back();
+
+                instance.name        = multinames.get(classes.values[i]->instance.name);
+                instance.superName   = multinames.get(classes.values[i]->instance.superName);
+                instance.flags       = classes.values[i]->instance.flags;
+                instance.protectedNs = namespaces.get(classes.values[i]->instance.protectedNs);
+                instance.interfaces.reserve(classes.values[i]->instance.interfaces.size());
+                for (const auto& iface : classes.values[i]->instance.interfaces)
+                {
+                    instance.interfaces.emplace_back(multinames.get(iface));
+                }
+                instance.iinit  = methods.get(classes.values[i]->instance.iinit);
+                instance.traits = convertTraits(classes.values[i]->instance.traits);
+            }
+
+            abc.classes.reserve(classes.values.size());
+            for (size_t i = 0; i < classes.values.size(); i++)
+            {
+                abc.classes.emplace_back(methods.get(classes.values[i]->cinit),
+                    convertTraits(classes.values[i]->traits));
+            }
+
+            abc.scripts.reserve(as.scripts.size());
+            for (size_t i = 0; i < as.scripts.size(); i++)
+            {
+                abc.scripts.emplace_back(
+                    methods.get(as.scripts[i].sinit), convertTraits(as.scripts[i].traits));
+            }
+
+            abc.bodies.reserve(bodies.size());
+            for (size_t i = 0; i < bodies.size(); i++)
+            {
+                ABC::MethodBody& body = abc.bodies.emplace_back();
+                body.method           = methods.get(bodies[i].method.lock());
+                body.maxStack         = bodies[i].maxStack;
+                body.localCount       = bodies[i].localCount;
+                body.initScopeDepth   = bodies[i].initScopeDepth;
+                body.maxScopeDepth    = bodies[i].maxScopeDepth;
+                body.instructions.reserve(bodies[i].instructions.size());
+                for (size_t j = 0; j < bodies[i].instructions.size(); j++)
+                {
+                    body.instructions.emplace_back(convertInstruction(bodies[i].instructions[j]));
+                }
+                body.exceptions.reserve(bodies[i].exceptions.size());
+                for (const auto& exception : bodies[i].exceptions)
+                {
+                    body.exceptions.emplace_back(exception.from, exception.to, exception.target,
+                        multinames.get(exception.excType), multinames.get(exception.varName));
+                }
+                body.traits = convertTraits(bodies[i].traits);
+            }
+        }
+
+        std::vector<ABC::TraitsInfo> convertTraits(const std::vector<ASASM::Trait>& traits)
+        {
+            std::vector<ABC::TraitsInfo> ret;
+            ret.reserve(traits.size());
+
+            for (const auto& oTrait : traits)
+            {
+                ABC::TraitsInfo& nTrait = ret.emplace_back();
+                nTrait.name             = multinames.get(oTrait.name);
+                nTrait.kind(oTrait.kind);
+                nTrait.attr(oTrait.attributes);
+                switch (oTrait.kind)
+                {
+                    case TraitKind::Slot:
+                    case TraitKind::Const:
+                        nTrait.Slot = {.slotId = oTrait.vSlot().slotId,
+                            .typeName          = multinames.get(oTrait.vSlot().typeName),
+                            .vindex            = getValueIndex(oTrait.vSlot().value),
+                            .vkind             = oTrait.vSlot().value.vkind};
+                        break;
+                    case TraitKind::Class:
+                        nTrait.Class = {.slotId = oTrait.vClass().slotId,
+                            .classi             = classes.get(oTrait.vClass().vclass)};
+                        break;
+                    case TraitKind::Function:
+                        nTrait.Function = {.slotId = oTrait.vFunction().slotId,
+                            .functioni             = methods.get(oTrait.vFunction().vfunction)};
+                        break;
+                    case TraitKind::Method:
+                    case TraitKind::Getter:
+                    case TraitKind::Setter:
+                        nTrait.Method = {.dispId = oTrait.vMethod().dispId,
+                            .method              = methods.get(oTrait.vMethod().vmethod)};
+                        break;
+                    default:
+                        throw StringException("Unknown trait kind");
+                }
+                nTrait.metadata.reserve(oTrait.metadata.size());
+                for (const auto& md : oTrait.metadata)
+                {
+                    nTrait.metadata.emplace_back(metadatas.get(md));
+                }
+            }
+            return ret;
+        }
+
+        ABC::Instruction convertInstruction(const ASASM::Instruction& instruction)
+        {
+            ABC::Instruction ret;
+            ret.opcode = instruction.opcode;
+            ret.arguments.reserve(instruction.arguments.size());
+
+            for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size(); i++)
+            {
+                ABC::Instruction::Argument& newArg = ret.arguments.emplace_back();
+                switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                {
+                    case OPCodeArgumentType::Unknown:
+                    default:
+                        throw StringException(
+                            "Don't know how to convert OP_" +
+                            std::string(OPCode_Info[(uint8_t)instruction.opcode].first));
+
+                    case OPCodeArgumentType::ByteLiteral:
+                        newArg.bytev(instruction.arguments[i].bytev());
+                        break;
+                    case OPCodeArgumentType::UByteLiteral:
+                        newArg.ubytev(instruction.arguments[i].ubytev());
+                        break;
+                    case OPCodeArgumentType::IntLiteral:
+                        newArg.intv(instruction.arguments[i].intv());
+                        break;
+                    case OPCodeArgumentType::UIntLiteral:
+                        newArg.uintv(instruction.arguments[i].uintv());
+                        break;
+
+                    case OPCodeArgumentType::Int:
+                        newArg.index(ints.get(instruction.arguments[i].intv()));
+                        break;
+                    case OPCodeArgumentType::UInt:
+                        newArg.index(uints.get(instruction.arguments[i].uintv()));
+                        break;
+                    case OPCodeArgumentType::Double:
+                        newArg.index(doubles.get(instruction.arguments[i].doublev()));
+                        break;
+                    case OPCodeArgumentType::String:
+                        newArg.index(strings.get(instruction.arguments[i].stringv()));
+                        break;
+                    case OPCodeArgumentType::Namespace:
+                        newArg.index(namespaces.get(instruction.arguments[i].namespacev()));
+                        break;
+                    case OPCodeArgumentType::Multiname:
+                        newArg.index(multinames.get(instruction.arguments[i].multinamev()));
+                        break;
+                    case OPCodeArgumentType::Class:
+                        if (instruction.arguments[i].classv() == nullptr)
+                        {
+                            newArg.index(abc.classes.size());
+                        }
+                        else
+                        {
+                            newArg.index(classes.get(instruction.arguments[i].classv()));
+                        }
+                        break;
+                    case OPCodeArgumentType::Method:
+                        if (instruction.arguments[i].methodv() == nullptr)
+                        {
+                            newArg.index(abc.methods.size());
+                        }
+                        else
+                        {
+                            newArg.index(methods.get(instruction.arguments[i].methodv()));
+                        }
+                        break;
+
+                    case OPCodeArgumentType::JumpTarget:
+                    case OPCodeArgumentType::SwitchDefaultTarget:
+                        newArg.jumpTarget(instruction.arguments[i].jumpTarget());
+                        break;
+
+                    case OPCodeArgumentType::SwitchTargets:
+                        newArg.switchTargets(
+                            std::vector<ABC::Label>(instruction.arguments[i].switchTargets()));
+                        break;
+                }
+            }
+
+            return ret;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Class.hpp b/Native/BytecodeEditor/include/ASASM/Class.hpp
new file mode 100644
index 0000000..32015e7
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Class.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "ASASM/Instance.hpp"
+#include "ASASM/Method.hpp"
+#include "ASASM/Trait.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace ASASM
+{
+    struct Class
+    {
+        std::shared_ptr<Method> cinit;
+        std::vector<Trait> traits;
+        Instance instance;
+
+        bool operator==(const Class& other) const = default;
+        bool operator<(const Class& other) const
+        {
+            if (cinit < other.cinit)
+            {
+                return true;
+            }
+            else if (cinit == other.cinit)
+            {
+                if (traits < other.traits)
+                {
+                    return instance < other.instance;
+                }
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Exception.hpp b/Native/BytecodeEditor/include/ASASM/Exception.hpp
new file mode 100644
index 0000000..bb64fb7
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Exception.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "ABC/Label.hpp"
+#include "ASASM/Multiname.hpp"
+
+namespace ASASM
+{
+    struct Exception
+    {
+        ABC::Label from, to, target;
+        Multiname excType;
+        Multiname varName;
+
+        bool operator==(const Exception&) const = default;
+        bool operator<(const Exception& other) const
+        {
+            if (from < other.from)
+            {
+                return true;
+            }
+            else if (from == other.from)
+            {
+                if (to < other.to)
+                {
+                    return true;
+                }
+                else if (to == other.to)
+                {
+                    if (target < other.target)
+                    {
+                        return true;
+                    }
+                    else if (target == other.target)
+                    {
+                        if (excType < other.excType)
+                        {
+                            return true;
+                        }
+                        else if (excType == other.excType)
+                        {
+                            return varName == other.varName;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Instance.hpp b/Native/BytecodeEditor/include/ASASM/Instance.hpp
new file mode 100644
index 0000000..19c1bc3
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Instance.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "ASASM/Method.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "ASASM/Trait.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <vector>
+
+namespace ASASM
+{
+    struct Instance
+    {
+        Multiname name;
+        Multiname superName;
+        uint8_t flags = 0;
+        Namespace protectedNs;
+        std::vector<Multiname> interfaces;
+        std::shared_ptr<Method> iinit;
+        std::vector<Trait> traits;
+
+        bool operator==(const Instance& other) const = default;
+        bool operator<(const Instance& other) const
+        {
+            if (name < other.name)
+            {
+                return true;
+            }
+            else if (name == other.name)
+            {
+                if (superName < other.superName)
+                {
+                    return true;
+                }
+                else if (superName == other.superName)
+                {
+                    if (flags < other.flags)
+                    {
+                        return true;
+                    }
+                    else if (flags == other.flags)
+                    {
+                        if (protectedNs < other.protectedNs)
+                        {
+                            return true;
+                        }
+                        else if (protectedNs == other.protectedNs)
+                        {
+                            if (interfaces < other.interfaces)
+                            {
+                                return true;
+                            }
+                            else if (interfaces == other.interfaces)
+                            {
+                                if (iinit < other.iinit)
+                                {
+                                    return true;
+                                }
+                                else if (iinit == other.iinit)
+                                {
+                                    return traits < other.traits;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Instruction.hpp b/Native/BytecodeEditor/include/ASASM/Instruction.hpp
new file mode 100644
index 0000000..9fad421
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Instruction.hpp
@@ -0,0 +1,163 @@
+#pragma once
+
+#include "ABC/Label.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "enums/OPCode.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <variant>
+
+namespace ASASM
+{
+    struct Class;
+    struct Method;
+    struct Instruction
+    {
+        OPCode opcode;
+        struct Argument
+        {
+        private:
+            std::variant<std::monostate, int8_t, uint8_t, int64_t, uint64_t, double, std::string,
+                Namespace, Multiname, std::shared_ptr<Class>, std::shared_ptr<Method>, ABC::Label,
+                std::vector<ABC::Label>>
+                data;
+
+        public:
+            [[nodiscard]] int8_t& bytev() { return std::get<int8_t>(data); }
+            [[nodiscard]] const int8_t& bytev() const { return std::get<int8_t>(data); }
+            void bytev(int8_t bytev) { data = bytev; }
+            [[nodiscard]] uint8_t& ubytev() { return std::get<uint8_t>(data); }
+            [[nodiscard]] const uint8_t& ubytev() const { return std::get<uint8_t>(data); }
+            void ubytev(uint8_t ubytev) { data = ubytev; }
+            [[nodiscard]] int64_t& intv() { return std::get<int64_t>(data); }
+            [[nodiscard]] const int64_t& intv() const { return std::get<int64_t>(data); }
+            void intv(int64_t intv) { data = intv; }
+            [[nodiscard]] uint64_t& uintv() { return std::get<uint64_t>(data); }
+            [[nodiscard]] const uint64_t& uintv() const { return std::get<uint64_t>(data); }
+            void uintv(uint64_t uintv) { data = uintv; }
+
+            [[nodiscard]] double& doublev() { return std::get<double>(data); }
+            [[nodiscard]] const double& doublev() const { return std::get<double>(data); }
+            void doublev(const double& v) { data = v; }
+            [[nodiscard]] std::string& stringv() { return std::get<std::string>(data); }
+            [[nodiscard]] const std::string& stringv() const { return std::get<std::string>(data); }
+            void stringv(const std::string& v) { data = v; }
+            [[nodiscard]] Namespace& namespacev() { return std::get<Namespace>(data); }
+            [[nodiscard]] const Namespace& namespacev() const { return std::get<Namespace>(data); }
+            void namespacev(const Namespace& v) { data = v; }
+            [[nodiscard]] Multiname& multinamev() { return std::get<Multiname>(data); }
+            [[nodiscard]] const Multiname& multinamev() const { return std::get<Multiname>(data); }
+            void multinamev(const Multiname& v) { data = v; }
+            [[nodiscard]] std::shared_ptr<Class>& classv()
+            {
+                return std::get<std::shared_ptr<Class>>(data);
+            }
+            [[nodiscard]] const std::shared_ptr<Class>& classv() const
+            {
+                return std::get<std::shared_ptr<Class>>(data);
+            }
+            void classv(std::shared_ptr<Class> v) { data = v; }
+            [[nodiscard]] std::shared_ptr<Method>& methodv()
+            {
+                return std::get<std::shared_ptr<Method>>(data);
+            }
+            [[nodiscard]] const std::shared_ptr<Method>& methodv() const
+            {
+                return std::get<std::shared_ptr<Method>>(data);
+            }
+            void methodv(std::shared_ptr<Method> v) { data = v; }
+
+            [[nodiscard]] ABC::Label& jumpTarget() { return std::get<ABC::Label>(data); }
+            [[nodiscard]] const ABC::Label& jumpTarget() const
+            {
+                return std::get<ABC::Label>(data);
+            }
+            void jumpTarget(const ABC::Label& v) { data = v; }
+            [[nodiscard]] std::vector<ABC::Label>& switchTargets()
+            {
+                return std::get<std::vector<ABC::Label>>(data);
+            }
+            [[nodiscard]] const std::vector<ABC::Label>& switchTargets() const
+            {
+                return std::get<std::vector<ABC::Label>>(data);
+            }
+            void switchTargets(const std::vector<ABC::Label>& v) { data = v; }
+
+            // std::weak_ordering operator<=>(const Argument& other) const noexcept
+            // {
+            //     if (data.valueless_by_exception() && other.data.valueless_by_exception())
+            //         return std::strong_ordering::equal;
+            //     if (data.valueless_by_exception() && !other.data.valueless_by_exception())
+            //         return std::strong_ordering::less;
+            //     if (!data.valueless_by_exception() && other.data.valueless_by_exception())
+            //         return std::strong_ordering::greater;
+            //     if (auto cmp = data.index() <=> other.data.index(); cmp != 0)
+            //         return cmp;
+            //     switch (data.index())
+            //     {
+            //         case 0:
+            //         default:
+            //             return std::strong_ordering::equal;
+            //         case 1:
+            //             return std::get<1>(data) <=> std::get<1>(other.data);
+            //         case 2:
+            //             return std::get<2>(data) <=> std::get<2>(other.data);
+            //         case 3:
+            //             return std::get<3>(data) <=>
+            //                    std::get<3>(other.data);
+            //         case 4:
+            //             return std::get<4>(data) <=> std::get<4>(other.data);
+            //         case 5:
+            //             return std::bit_cast<uint64_t>(std::get<5>(data)) <=>
+            //                    std::bit_cast<uint64_t>(std::get<5>(other.data));
+            //         case 6:
+            //             return std::get<6>(data) <=> std::get<6>(other.data);
+            //         case 7:
+            //             return std::get<7>(data) <=> std::get<7>(other.data);
+            //         case 8:
+            //             return std::get<8>(data) <=> std::get<8>(other.data);
+            //         case 9:
+            //             return std::get<9>(data) <=> std::get<9>(other.data);
+            //         case 10:
+            //             return std::get<10>(data) <=> std::get<10>(other.data);
+            //         case 11:
+            //             return std::get<11>(data) <=> std::get<11>(other.data);
+            //         case 12:
+            //             return std::get<12>(data) <=> std::get<12>(other.data);
+            //     }
+            // }
+
+            bool operator==(const Argument& other) const = default;
+            bool operator<(const Argument& other) const
+            {
+                if (data.valueless_by_exception() && other.data.valueless_by_exception())
+                    return false;
+                if (data.valueless_by_exception() && !other.data.valueless_by_exception())
+                    return true;
+                if (!data.valueless_by_exception() && other.data.valueless_by_exception())
+                    return false;
+
+                return data < other.data;
+            }
+        };
+
+        std::vector<Argument> arguments;
+
+        bool operator==(const Instruction& other) const = default;
+        bool operator<(const Instruction& other) const
+        {
+            if (opcode < other.opcode)
+            {
+                return true;
+            }
+            if (opcode == other.opcode)
+            {
+                return arguments < other.arguments;
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Metadata.hpp b/Native/BytecodeEditor/include/ASASM/Metadata.hpp
new file mode 100644
index 0000000..73f9c29
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Metadata.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ASASM
+{
+    struct Metadata
+    {
+        std::string name;
+        std::vector<std::pair<std::string, std::string>> data;
+
+        bool operator==(const Metadata& other) const = default;
+        bool operator<(const Metadata& other) const
+        {
+            if (name < other.name)
+            {
+                return true;
+            }
+            if (name == other.name)
+            {
+                return data < other.data;
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Method.hpp b/Native/BytecodeEditor/include/ASASM/Method.hpp
new file mode 100644
index 0000000..4bdf4bf
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Method.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "ASASM/MethodBody.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Value.hpp"
+
+#include <optional>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace ASASM
+{
+    struct Method
+    {
+        std::vector<Multiname> paramTypes;
+        Multiname returnType;
+        std::string name;
+        uint8_t flags = 0;
+        std::vector<Value> options;
+        std::vector<std::string> paramNames;
+
+        uint32_t id = 0;
+
+        std::optional<MethodBody> vbody;
+
+        std::string toString() const { return name; }
+
+        bool operator==(const Method& other) const = default;
+        bool operator<(const Method& other) const
+        {
+            if (paramTypes < other.paramTypes)
+            {
+                return true;
+            }
+            if (paramTypes == other.paramTypes)
+            {
+                if (returnType < other.returnType)
+                {
+                    return true;
+                }
+                if (returnType == other.returnType)
+                {
+                    if (name < other.name)
+                    {
+                        return true;
+                    }
+                    if (name == other.name)
+                    {
+                        if (flags < other.flags)
+                        {
+                            return true;
+                        }
+                        if (flags == other.flags)
+                        {
+                            if (options < other.options)
+                            {
+                                return true;
+                            }
+                            if (options == other.options)
+                            {
+                                if (paramNames < other.paramNames)
+                                {
+                                    return true;
+                                }
+                                if (paramNames == other.paramNames)
+                                {
+                                    if (id < other.id)
+                                    {
+                                        return true;
+                                    }
+                                    if (id == other.id)
+                                    {
+                                        return vbody < other.vbody;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/MethodBody.hpp b/Native/BytecodeEditor/include/ASASM/MethodBody.hpp
new file mode 100644
index 0000000..4ef01c8
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/MethodBody.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "ABC/Error.hpp"
+#include "ASASM/Exception.hpp"
+#include "ASASM/Instruction.hpp"
+#include "ASASM/Trait.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <vector>
+
+namespace ASASM
+{
+    struct Method;
+    struct MethodBody
+    {
+        std::weak_ptr<Method> method;
+        uint32_t maxStack = 0;
+        uint32_t localCount = 0;
+        uint32_t initScopeDepth = 0;
+        uint32_t maxScopeDepth = 0;
+
+        std::vector<Instruction> instructions;
+        std::vector<Exception> exceptions;
+        std::vector<Trait> traits;
+
+        std::vector<ABC::Error> errors;
+
+        bool operator==(const MethodBody& other) const = default;
+        bool operator<(const MethodBody& other) const
+        {
+            if (maxStack < other.maxStack)
+            {
+                return true;
+            }
+            if (maxStack == other.maxStack)
+            {
+                if (localCount < other.localCount)
+                {
+                    return true;
+                }
+                if (localCount == other.localCount)
+                {
+                    if (initScopeDepth < other.initScopeDepth)
+                    {
+                        return true;
+                    }
+                    if (initScopeDepth == other.initScopeDepth)
+                    {
+                        if (maxScopeDepth < other.maxScopeDepth)
+                        {
+                            return true;
+                        }
+                        if (maxScopeDepth == other.maxScopeDepth)
+                        {
+                            if (instructions < other.instructions)
+                            {
+                                return true;
+                            }
+                            if (instructions == other.instructions)
+                            {
+                                if (exceptions < other.exceptions)
+                                {
+                                    return true;
+                                }
+                                if (exceptions == other.exceptions)
+                                {
+                                    if (traits < other.traits)
+                                    {
+                                        return true;
+                                    }
+                                    if (traits == other.traits)
+                                    {
+                                        return errors < other.errors;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Multiname.hpp b/Native/BytecodeEditor/include/ASASM/Multiname.hpp
new file mode 100644
index 0000000..a9c7e63
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Multiname.hpp
@@ -0,0 +1,200 @@
+#pragma once
+
+#include "ASASM/Namespace.hpp"
+#include "enums/ABCType.hpp"
+#include "utils/StringException.hpp"
+
+#include <memory>
+#include <stdint.h>
+#include <variant>
+#include <vector>
+
+namespace ASASM
+{
+    struct Multiname
+    {
+        struct _QName
+        {
+            Namespace ns;
+            std::string name;
+            bool operator==(const _QName& other) const = default;
+            bool operator<(const _QName& other) const
+            {
+                if (ns < other.ns)
+                {
+                    return true;
+                }
+                if (ns == other.ns)
+                {
+                    return name < other.name;
+                }
+                return false;
+            }
+        };
+        struct _RTQName
+        {
+            std::string name;
+            bool operator==(const _RTQName& other) const = default;
+            bool operator<(const _RTQName& other) const { return name < other.name; }
+        };
+        struct _RTQNameL
+        {
+            bool operator==(const _RTQNameL&) const { return true; }
+            bool operator<(const _RTQNameL&) const { return false; }
+        };
+        struct _Multiname
+        {
+            std::string name;
+            std::vector<Namespace> nsSet;
+            bool operator==(const _Multiname& other) const = default;
+            bool operator<(const _Multiname& other) const
+            {
+                if (name < other.name)
+                {
+                    return true;
+                }
+                if (name == other.name)
+                {
+                    return nsSet < other.nsSet;
+                }
+                return false;
+            }
+        };
+        struct _MultinameL
+        {
+            std::vector<Namespace> nsSet;
+            bool operator==(const _MultinameL& other) const = default;
+            bool operator<(const _MultinameL& other) const { return nsSet < other.nsSet; }
+        };
+        struct _Typename
+        {
+        private:
+            std::unique_ptr<Multiname> _name;
+            std::unique_ptr<std::vector<Multiname>> _params;
+
+        public:
+            _Typename()
+                : _name(std::make_unique<Multiname>()),
+                  _params(std::make_unique<std::vector<Multiname>>())
+            {
+            }
+            explicit _Typename(const Multiname& n)
+                : _name(std::make_unique<Multiname>(n)),
+                  _params(std::make_unique<std::vector<Multiname>>())
+            {
+            }
+            _Typename(const Multiname& n, const std::vector<Multiname>& params)
+                : _name(std::make_unique<Multiname>(n)),
+                  _params(std::make_unique<std::vector<Multiname>>(params))
+            {
+            }
+
+            _Typename(const _Typename& other) : _Typename(*other._name, *other._params) {}
+            _Typename(_Typename&& other) noexcept
+                : _name(std::move(other._name)), _params(std::move(other._params))
+            {
+            }
+
+            _Typename& operator=(const _Typename& other)
+            {
+                *_name   = *other._name;
+                *_params = *other._params;
+                return *this;
+            }
+            _Typename& operator=(_Typename&& other) noexcept
+            {
+                _name   = std::move(other._name);
+                _params = std::move(other._params);
+                return *this;
+            }
+
+            ~_Typename() = default;
+
+            const Multiname& name() const { return *_name; }
+            Multiname& name() { return *_name; }
+
+            const std::vector<Multiname>& params() const { return *_params; }
+            std::vector<Multiname>& params() { return *_params; }
+
+            // std::weak_ordering operator<=>(const _Typename& other) const
+            // {
+            //     if (auto cmp = (name() <=> other.name()); cmp != 0)
+            //     {
+            //         return cmp;
+            //     }
+            //     return params() <=> other.params();
+            // }
+
+            bool operator==(const _Typename& other) const
+            {
+                return name() == other.name() && params() == other.params();
+            }
+            bool operator<(const _Typename& other) const
+            {
+                if (name() < other.name())
+                {
+                    return true;
+                }
+                if (name() == other.name())
+                {
+                    return params() < other.params();
+                }
+                return false;
+            }
+        };
+
+        ABCType kind = ABCType::Void;
+
+        [[nodiscard]] const _QName& qname() const { return std::get<_QName>(data); }
+        [[nodiscard]] _QName& qname() { return std::get<_QName>(data); }
+        void qname(const _QName& v) { data = v; }
+        [[nodiscard]] const _RTQName& rtqname() const { return std::get<_RTQName>(data); }
+        [[nodiscard]] _RTQName& rtqname() { return std::get<_RTQName>(data); }
+        void rtqname(const _RTQName& v) { data = v; }
+        [[nodiscard]] const _RTQNameL& rtqnamel() const { return std::get<_RTQNameL>(data); }
+        [[nodiscard]] _RTQNameL& rtqnamel() { return std::get<_RTQNameL>(data); }
+        void rtqnamel(const _RTQNameL& v) { data = v; }
+        [[nodiscard]] const _Multiname& multiname() const { return std::get<_Multiname>(data); }
+        [[nodiscard]] _Multiname& multiname() { return std::get<_Multiname>(data); }
+        void multiname(const _Multiname& v) { data = v; }
+        [[nodiscard]] const _MultinameL& multinamel() const { return std::get<_MultinameL>(data); }
+        [[nodiscard]] _MultinameL& multinamel() { return std::get<_MultinameL>(data); }
+        void multinamel(const _MultinameL& v) { data = v; }
+        [[nodiscard]] const _Typename& Typename() const { return std::get<_Typename>(data); }
+        [[nodiscard]] _Typename& Typename() { return std::get<_Typename>(data); }
+        void Typename(const _Typename& v) { data = v; }
+
+        std::vector<Multiname> toQNames() const
+        {
+            switch (kind)
+            {
+                case ABCType::QName:
+                case ABCType::QNameA:
+                    return {*this};
+                case ABCType::Multiname:
+                case ABCType::MultinameA:
+                {
+                    std::vector<Multiname> ret;
+                    for (const auto& ns : multiname().nsSet)
+                    {
+                        Multiname add;
+                        add.kind = kind == ABCType::Multiname ? ABCType::QName : ABCType::QNameA;
+                        add.qname({ns, multiname().name});
+                        ret.emplace_back(std::move(add));
+                    }
+                    return ret;
+                }
+                default:
+                    throw StringException("Can't expand Multiname of this kind");
+            }
+        }
+
+        bool operator==(const Multiname& m) const { return data == m.data; }
+        bool operator<(const Multiname& m) const { return data < m.data; }
+
+    private:
+        std::variant<std::monostate, _QName, _RTQName, _RTQNameL, _Multiname, _MultinameL,
+            _Typename>
+            data;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Namespace.hpp b/Native/BytecodeEditor/include/ASASM/Namespace.hpp
new file mode 100644
index 0000000..b3d0c9a
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Namespace.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "enums/ABCType.hpp"
+
+#include <stdint.h>
+#include <string>
+
+namespace ASASM
+{
+    struct Namespace
+    {
+        ABCType kind = ABCType::Void;
+        std::string name;
+
+        int id = 0;
+
+        bool operator==(const Namespace& other) const = default;
+        bool operator<(const Namespace& other) const
+        {
+            if (kind < other.kind)
+            {
+                return true;
+            }
+            if (kind == other.kind)
+            {
+                if (name < other.name)
+                {
+                    return true;
+                }
+                if (name == other.name)
+                {
+                    return id < other.id;
+                }
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Script.hpp b/Native/BytecodeEditor/include/ASASM/Script.hpp
new file mode 100644
index 0000000..a2f5893
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Script.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "ASASM/Method.hpp"
+#include "ASASM/Trait.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace ASASM
+{
+    struct Script
+    {
+        std::shared_ptr<Method> sinit;
+        std::vector<Trait> traits;
+
+        bool operator==(const Script& other) const = default;
+        bool operator<(const Script& other) const
+        {
+            if (sinit < other.sinit)
+            {
+                return true;
+            }
+            if (sinit == other.sinit)
+            {
+                return traits < traits;
+            }
+            return false;
+        }
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Trait.hpp b/Native/BytecodeEditor/include/ASASM/Trait.hpp
new file mode 100644
index 0000000..98e5787
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Trait.hpp
@@ -0,0 +1,156 @@
+#pragma once
+
+#include "ASASM/Metadata.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Value.hpp"
+#include "enums/TraitKind.hpp"
+
+#include <memory>
+#include <stdint.h>
+
+namespace ASASM
+{
+    struct Class;
+    struct Method;
+
+    struct Trait
+    {
+        struct _Slot
+        {
+            uint32_t slotId;
+            Multiname typeName;
+            Value value;
+            bool operator==(const _Slot& other) const = default;
+            bool operator<(const _Slot& other) const
+            {
+                if (slotId < other.slotId)
+                {
+                    return true;
+                }
+                if (slotId == other.slotId)
+                {
+                    if (typeName < other.typeName)
+                    {
+                        return true;
+                    }
+                    if (typeName == other.typeName)
+                    {
+                        return value < other.value;
+                    }
+                }
+                return false;
+            }
+        };
+        struct _Class
+        {
+            uint32_t slotId;
+            std::shared_ptr<Class> vclass;
+            bool operator==(const _Class& other) const = default;
+            bool operator<(const _Class& other) const
+            {
+                if (slotId < other.slotId)
+                {
+                    return true;
+                }
+                if (slotId == other.slotId)
+                {
+                    return vclass < other.vclass;
+                }
+                return false;
+            }
+        };
+        struct _Function
+        {
+            uint32_t slotId;
+            std::shared_ptr<Method> vfunction;
+            bool operator==(const _Function& other) const = default;
+            bool operator<(const _Function& other) const
+            {
+                if (slotId < other.slotId)
+                {
+                    return true;
+                }
+                if (slotId == other.slotId)
+                {
+                    return vfunction < other.vfunction;
+                }
+                return false;
+            }
+        };
+        struct _Method
+        {
+            uint32_t dispId;
+            std::shared_ptr<Method> vmethod;
+            bool operator==(const _Method& other) const = default;
+            bool operator<(const _Method& other) const
+            {
+                if (dispId < other.dispId)
+                {
+                    return true;
+                }
+                if (dispId == other.dispId)
+                {
+                    return vmethod < other.vmethod;
+                }
+                return false;
+            }
+        };
+
+        Multiname name;
+        TraitKind kind;
+        uint8_t attributes = 0;
+
+        std::vector<Metadata> metadata;
+
+        [[nodiscard]] _Slot& vSlot() { return std::get<_Slot>(data); }
+        [[nodiscard]] const _Slot& vSlot() const { return std::get<_Slot>(data); }
+        void vSlot(const _Slot& v) { data = v; }
+        [[nodiscard]] _Class& vClass() { return std::get<_Class>(data); }
+        [[nodiscard]] const _Class& vClass() const { return std::get<_Class>(data); }
+        void vClass(const _Class& v) { data = v; }
+        [[nodiscard]] _Function& vFunction() { return std::get<_Function>(data); }
+        [[nodiscard]] const _Function& vFunction() const { return std::get<_Function>(data); }
+        void vFunction(const _Function& v) { data = v; }
+        [[nodiscard]] _Method& vMethod() { return std::get<_Method>(data); }
+        [[nodiscard]] const _Method& vMethod() const { return std::get<_Method>(data); }
+        void vMethod(const _Method& v) { data = v; }
+
+        bool operator==(const Trait& other) const = default;
+        bool operator<(const Trait& other) const
+        {
+            if (name < other.name)
+            {
+                return true;
+            }
+            if (name == other.name)
+            {
+                if (kind < other.kind)
+                {
+                    return true;
+                }
+                if (kind == other.kind)
+                {
+                    if (attributes < other.attributes)
+                    {
+                        return true;
+                    }
+                    if (attributes == other.attributes)
+                    {
+                        if (metadata < other.metadata)
+                        {
+                            return true;
+                        }
+                        if (metadata == other.metadata)
+                        {
+                            return data < other.data;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+    private:
+        std::variant<std::monostate, _Slot, _Class, _Function, _Method> data;
+    };
+}
diff --git a/Native/BytecodeEditor/include/ASASM/Value.hpp b/Native/BytecodeEditor/include/ASASM/Value.hpp
new file mode 100644
index 0000000..c7dabe2
--- /dev/null
+++ b/Native/BytecodeEditor/include/ASASM/Value.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "ASASM/Namespace.hpp"
+#include "enums/ABCType.hpp"
+
+#include <variant>
+
+namespace ASASM
+{
+    struct Value
+    {
+        ABCType vkind = ABCType::Void;
+
+        [[nodiscard]] int64_t& vint() { return std::get<int64_t>(data); }
+        [[nodiscard]] const int64_t& vint() const { return std::get<int64_t>(data); }
+        void vint(int64_t intv) { data = intv; }
+        [[nodiscard]] uint64_t& vuint() { return std::get<uint64_t>(data); }
+        [[nodiscard]] const uint64_t& vuint() const { return std::get<uint64_t>(data); }
+        void vuint(uint64_t uintv) { data = uintv; }
+        [[nodiscard]] double& vdouble() { return std::get<double>(data); }
+        [[nodiscard]] const double& vdouble() const { return std::get<double>(data); }
+        void vdouble(const double& v) { data = v; }
+        [[nodiscard]] std::string& vstring() { return std::get<std::string>(data); }
+        [[nodiscard]] const std::string& vstring() const { return std::get<std::string>(data); }
+        void vstring(const std::string& v) { data = v; }
+        [[nodiscard]] Namespace& vnamespace() { return std::get<Namespace>(data); }
+        [[nodiscard]] const Namespace& vnamespace() const { return std::get<Namespace>(data); }
+        void vnamespace(const Namespace& v) { data = v; }
+
+        bool operator==(const Value& other) const = default;
+        bool operator<(const Value& other) const
+        {
+            if (data.valueless_by_exception() && other.data.valueless_by_exception())
+                return false;
+            if (data.valueless_by_exception() && !other.data.valueless_by_exception())
+                return true;
+            if (!data.valueless_by_exception() && other.data.valueless_by_exception())
+                return false;
+
+            return data < other.data;
+        }
+
+        // std::strong_ordering operator<=>(const Value& other) const noexcept
+        // {
+        //     if (data.valueless_by_exception() && other.data.valueless_by_exception())
+        //         return std::strong_ordering::equal;
+        //     if (data.valueless_by_exception() && !other.data.valueless_by_exception())
+        //         return std::strong_ordering::less;
+        //     if (!data.valueless_by_exception() && other.data.valueless_by_exception())
+        //         return std::strong_ordering::greater;
+        //     if (auto cmp = data.index() <=> other.data.index(); cmp != 0)
+        //         return cmp;
+        //     switch (data.index())
+        //     {
+        //         case 0:
+        //             return std::strong_ordering::equal;
+        //         case 1:
+        //             return std::get<1>(data) <=> std::get<1>(other.data);
+        //         case 2:
+        //             return std::get<2>(data) <=> std::get<2>(other.data);
+        //         case 3:
+        //             return std::bit_cast<uint64_t>(std::get<3>(data)) <=>
+        //                    std::bit_cast<uint64_t>(std::get<3>(other.data));
+        //         case 4:
+        //             return std::get<4>(data) <=> std::get<4>(other.data);
+        //         case 5:
+        //             return std::get<5>(data) <=> std::get<5>(other.data);
+        //     }
+        // }
+
+    private:
+        std::variant<std::monostate, int64_t, uint64_t, double, std::string, Namespace> data;
+    };
+}
diff --git a/Native/BytecodeEditor/include/Assembler.hpp b/Native/BytecodeEditor/include/Assembler.hpp
new file mode 100644
index 0000000..e79bf01
--- /dev/null
+++ b/Native/BytecodeEditor/include/Assembler.hpp
@@ -0,0 +1,1592 @@
+#pragma once
+
+#include "ASASM/ASProgram.hpp"
+#include "ASASM/Class.hpp"
+#include "ASASM/Exception.hpp"
+#include "ASASM/Instance.hpp"
+#include "ASASM/Instruction.hpp"
+#include "ASASM/Metadata.hpp"
+#include "ASASM/Method.hpp"
+#include "ASASM/MethodBody.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "ASASM/Script.hpp"
+#include "ASASM/Trait.hpp"
+#include "ASASM/Value.hpp"
+#include "enums/ABCType.hpp"
+#include "enums/InstanceFlags.hpp"
+#include "enums/MethodFlags.hpp"
+#include "enums/TraitAttribute.hpp"
+#include "utils/StringException.hpp"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+class Assembler
+{
+private:
+    const std::unordered_map<std::string, std::string>& strings;
+
+    static constexpr char addUniqueMethod[] = "method";
+    static constexpr char addUniqueClass[]  = "class";
+    static constexpr char addUniqueLabel[]  = "label";
+
+    struct SourceFile : public std::enable_shared_from_this<SourceFile>
+    {
+        std::string name;
+        std::vector<std::string> arguments;
+        std::string data;
+        bool isVirtual() { return data != ""; }
+
+        std::shared_ptr<SourceFile> parent;
+
+        size_t filePosition;
+
+        SourceFile(std::string_view name, std::string_view data,
+            const std::vector<std::string>& arguments = {})
+            : name(name), arguments(arguments), data(data), filePosition(0)
+        {
+            if (data.empty())
+            {
+                throw StringException("Empty source file");
+            }
+        }
+
+        struct Position
+        {
+            std::shared_ptr<SourceFile> file;
+            size_t offset;
+
+            const std::shared_ptr<SourceFile>& load() const
+            {
+                file->filePosition = offset;
+                return file;
+            }
+        };
+
+        Position position() { return Position(shared_from_this(), filePosition); }
+
+        std::string positionStr()
+        {
+            size_t lineStart = 0;
+            size_t line      = 1;
+            for (size_t i = 0; i < data.size(); i++)
+            {
+                if (i == filePosition)
+                {
+                    return name + "(" + std::to_string(line) + "," +
+                           std::to_string(i - lineStart + 1) + ")";
+                }
+                if (data[i] == '\n')
+                {
+                    line++;
+                    lineStart = i;
+                }
+            }
+
+            return name + "(???)";
+        }
+
+        char front() { return data[filePosition]; }
+
+        void popFront() { filePosition++; }
+    };
+
+    using Position = SourceFile::Position;
+
+    std::shared_ptr<SourceFile> currentFile;
+
+    void skipWhitespace()
+    {
+        while (true)
+        {
+            char c;
+            while ((c = peekChar()) == 0)
+            {
+                popFile();
+            }
+            if (c == ' ' || c == '\r' || c == '\n' || c == '\t')
+            {
+                skipChar();
+            }
+            else if (c == '#')
+            {
+                handlePreprocessor();
+            }
+            else if (c == '$')
+            {
+                handleVar();
+            }
+            else if (c == ';')
+            {
+                do
+                {
+                    skipChar();
+                } while (peekChar() != '\n');
+            }
+            else
+            {
+                return;
+            }
+        }
+    }
+
+    std::unordered_map<std::string, std::string> vars;
+    std::unordered_map<std::string, uint32_t> namespaceLabels;
+    uint32_t sourceVersion = 1;
+
+    void handlePreprocessor()
+    {
+        skipChar(); // #
+        std::string word = readWord();
+
+        if (word == "mixin")
+        {
+            pushFile(std::make_shared<SourceFile>("#mixin", readString()));
+        }
+        else if (word == "call")
+        {
+            auto rsLambda = [this] { return readString(); };
+            pushFile(std::make_shared<SourceFile>(
+                "#call", readString(), readList<'(', ')', false>([this] { return readString(); })));
+        }
+        else if (word == "include")
+        {
+            std::string s = readString();
+            pushFile(std::make_shared<SourceFile>(s, strings.at(s)));
+        }
+        else if (word == "get")
+        {
+            std::string s = readString();
+            pushFile(std::make_shared<SourceFile>(s, toStringLiteral(strings.at(s))));
+        }
+        else if (word == "set")
+        {
+            vars[readWord()] = readString();
+        }
+        else if (word == "unset")
+        {
+            vars.erase(readWord());
+        }
+        else if (word == "privatens")
+        {
+            if (sourceVersion >= 3)
+            {
+                throw StringException("#privatens is deprecated");
+            }
+            readUInt();
+            readString();
+        }
+        else if (word == "version")
+        {
+            sourceVersion = readUInt();
+            if (sourceVersion < 1 || sourceVersion > 4)
+            {
+                throw StringException("Invalid/unknown #version");
+            }
+        }
+        else
+        {
+            backpedal(word.size());
+            throw StringException("Unknown preprocessor declaration: " + word);
+        }
+    }
+
+    void handleVar()
+    {
+        skipChar(); // $
+        skipWhitespace();
+
+        std::string name;
+        bool asStringLiteral = false;
+        if (peekChar() == '"')
+        {
+            name            = readString();
+            asStringLiteral = true;
+        }
+        else
+        {
+            name = readWord();
+        }
+
+        if (name.size() == 0)
+        {
+            throw StringException("Empty variable name");
+        }
+        if (name[0] >= '1' && name[0] <= '9')
+        {
+            for (std::shared_ptr<SourceFile> f = currentFile; f != nullptr; f = f->parent)
+            {
+                if (!f->arguments.empty())
+                {
+                    size_t index = atoi(name.c_str()) - 1;
+                    if (index >= f->arguments.size())
+                    {
+                        throw StringException("Argument index out of bounds");
+                    }
+                    pushFile(std::make_shared<SourceFile>(
+                        '$' + name, asStringLiteral ? toStringLiteral(f->arguments[index])
+                                                    : f->arguments[index]));
+                    return;
+                }
+            }
+            throw StringException("No arguments in context");
+        }
+        else
+        {
+            if (!vars.contains(name))
+            {
+                throw StringException("Variable " + name + " is not defined");
+            }
+            pushFile(std::make_shared<SourceFile>(
+                '$' + name, asStringLiteral ? toStringLiteral(vars.at(name)) : vars.at(name)));
+        }
+    }
+
+    static bool isWordChar(char c)
+    {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
+               c == '_' || c == '-' || c == '+' || c == '.';
+    }
+
+    std::string readWord()
+    {
+        skipWhitespace();
+        if (!isWordChar(currentFile->front()))
+        {
+            // throw StringException("Word character expected");
+            return {};
+        }
+        std::string ret;
+        while (true)
+        {
+            char c = currentFile->front();
+            if (!isWordChar(c))
+                break;
+            ret += c;
+            currentFile->popFront();
+        }
+        return ret;
+    }
+
+    uint8_t fromHex(char x)
+    {
+        switch (x)
+        {
+            case '0':
+                return 0x0;
+            case '1':
+                return 0x1;
+            case '2':
+                return 0x2;
+            case '3':
+                return 0x3;
+            case '4':
+                return 0x4;
+            case '5':
+                return 0x5;
+            case '6':
+                return 0x6;
+            case '7':
+                return 0x7;
+            case '8':
+                return 0x8;
+            case '9':
+                return 0x9;
+            case 'a':
+            case 'A':
+                return 0xa;
+            case 'b':
+            case 'B':
+                return 0xb;
+            case 'c':
+            case 'C':
+                return 0xc;
+            case 'd':
+            case 'D':
+                return 0xd;
+            case 'e':
+            case 'E':
+                return 0xe;
+            case 'f':
+            case 'F':
+                return 0xf;
+            default:
+                throw StringException(std::string("Malformed hex digit ") + x);
+        }
+    }
+
+    void pushFile(std::shared_ptr<SourceFile> f)
+    {
+        f->parent   = currentFile;
+        currentFile = f;
+    }
+
+    void setFile(std::shared_ptr<SourceFile> f) { currentFile = f; }
+
+    void popFile()
+    {
+        if (!currentFile || !currentFile->parent)
+        {
+            throw StringException("Unexpected end of file");
+        }
+        currentFile = currentFile->parent;
+    }
+
+    void expectWord(std::string_view expected)
+    {
+        std::string word = readWord();
+        if (word != expected)
+        {
+            backpedal(word.size());
+            throw StringException("Expected " + std::string(expected));
+        }
+    }
+
+    char peekChar() { return currentFile->front(); }
+
+    void skipChar() { currentFile->popFront(); }
+
+    void backpedal(size_t amount = 1) { currentFile->filePosition -= amount; }
+
+    char readChar()
+    {
+        char ret = peekChar();
+        if (ret != '\0')
+        {
+            skipChar();
+        }
+        return ret;
+    }
+
+    char readSymbol()
+    {
+        skipWhitespace();
+        return readChar();
+    }
+
+    void expectSymbol(char c)
+    {
+        if (readSymbol() != c)
+        {
+            backpedal();
+            throw StringException(std::string("Expected ") + c);
+        }
+    }
+
+    // *****************************
+
+    template <typename T>
+    void mustBeNull(const T& obj)
+    {
+        using comp                 = std::remove_cvref_t<T>;
+        static constexpr auto fail = [] { throw StringException("Repeated field declaration"); };
+        if constexpr (std::is_same_v<ASASM::Multiname, comp> ||
+                      std::is_same_v<ASASM::Namespace, comp>)
+        {
+            if (obj.kind != ABCType::Void)
+            {
+                fail();
+            }
+        }
+        else if constexpr (std::is_same_v<std::shared_ptr<ASASM::Class>, comp> ||
+                           std::is_same_v<std::shared_ptr<ASASM::Method>, comp>)
+        {
+            if (obj != nullptr)
+            {
+                fail();
+            }
+        }
+        else if constexpr (std::is_same_v<std::string, comp>)
+        {
+            if (!obj.empty())
+            {
+                fail();
+            }
+        }
+        else if constexpr (std::is_same_v<ASASM::Instance, comp>)
+        {
+            mustBeNull(obj.iinit);
+        }
+        else
+        {
+            static_assert(std::is_same_v<void, comp>);
+        }
+    }
+
+    template <const char* name, typename T>
+    void mustBeSet(const T& obj)
+    {
+        using comp                 = std::remove_cvref_t<T>;
+        static constexpr auto fail = [] { throw StringException(std::string(name) + " not set"); };
+        if constexpr (std::is_same_v<std::shared_ptr<ASASM::Method>, comp>)
+        {
+            if (obj == nullptr)
+            {
+                fail();
+            }
+        }
+        else if constexpr (std::is_same_v<ASASM::Instance, comp>)
+        {
+            mustBeSet<name>(obj.iinit);
+        }
+        else
+        {
+            static_assert(std::is_same_v<void, comp>);
+        }
+    }
+
+    static ABCType toABCType(std::string_view name)
+    {
+        auto found = ABCTypeMap.Find(name.data());
+        if (!found)
+        {
+            throw StringException("Unknown ABCType " + std::string(name));
+        }
+        return *found;
+    }
+
+    template <const char* name, typename K, typename V>
+    static void addUnique(std::unordered_map<K, V>& aa, K k, V v)
+    {
+        if (aa.contains(k))
+        {
+            throw StringException("Duplicate " + std::string(name));
+        }
+        aa.emplace(k, v);
+    }
+
+    static std::string toStringLiteral(std::string_view str)
+    {
+        // if (str.empty()) return "null"; else
+        {
+            static constexpr std::array<char, 16> hexDigits = {
+                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+            std::string ret = "\"";
+            ret.reserve(str.size());
+            for (char c : str)
+            {
+                if (c == '\n')
+                {
+                    ret += "\\n";
+                }
+                else if (c == '\r')
+                {
+                    ret += "\\r";
+                }
+                else if (c == '\\')
+                {
+                    ret += "\\\\";
+                }
+                else if (c == '"')
+                {
+                    ret += "\\\"";
+                }
+                else
+                {
+                    unsigned char uc = c;
+                    if (uc < 0x20 || uc >= 0x7F)
+                    {
+                        ret += "\\x";
+                        ret += hexDigits[uc / 0x10];
+                        ret += hexDigits[uc % 0x10];
+                    }
+                    else
+                    {
+                        ret += c;
+                    }
+                }
+            }
+            ret += '"';
+
+            return ret;
+        }
+    }
+
+    ASASM::Value readValue()
+    {
+        ASASM::Value ret;
+        ret.vkind = toABCType(readWord());
+        expectSymbol('(');
+        switch (ret.vkind)
+        {
+            case ABCType::Integer:
+                ret.vint(readInt());
+                break;
+            case ABCType::UInteger:
+                ret.vuint(readUInt());
+                break;
+            case ABCType::Double:
+                ret.vdouble(readDouble());
+                break;
+            case ABCType::Utf8:
+                ret.vstring(readString());
+                break;
+            case ABCType::Namespace:
+            case ABCType::PackageNamespace:
+            case ABCType::PackageInternalNs:
+            case ABCType::ProtectedNamespace:
+            case ABCType::ExplicitNamespace:
+            case ABCType::StaticProtectedNs:
+            case ABCType::PrivateNamespace:
+                ret.vnamespace(readNamespace());
+                break;
+            case ABCType::True:
+            case ABCType::False:
+            case ABCType::Null:
+            case ABCType::Undefined:
+                break;
+            default:
+                throw StringException("Unknown type");
+        }
+        expectSymbol(')');
+        return ret;
+    }
+
+    template <typename T>
+    uint8_t readFlag(const T& BiMap)
+    {
+        auto word  = readWord();
+        auto found = BiMap.Find(word.c_str());
+        if (!found)
+        {
+            backpedal(word.size());
+            throw StringException("Unknown flag " + word);
+        }
+        return uint8_t(*found);
+    }
+
+    template <char OPEN, char CLOSE, bool ALLOW_NULL, typename Reader>
+    std::vector<decltype(std::declval<Reader>()())> readList(const Reader& r)
+    {
+        if constexpr (ALLOW_NULL)
+        {
+            skipWhitespace();
+            if (peekChar() != OPEN)
+            {
+                std::string word = readWord();
+                if (word != "null")
+                {
+                    backpedal(word.size());
+                    throw StringException(std::string("Expected ") + OPEN + " or null");
+                }
+                return {};
+            }
+        }
+
+        expectSymbol(OPEN);
+        std::vector<decltype(std::declval<Reader>()())> ret;
+
+        skipWhitespace();
+        if (peekChar() == CLOSE)
+        {
+            skipChar(); // CLOSE
+            return {};
+        }
+        while (true)
+        {
+            ret.emplace_back(r());
+            char c = readSymbol();
+            if (c == CLOSE)
+                break;
+            if (c != ',')
+            {
+                backpedal();
+                throw StringException(std::string("Expected ") + CLOSE + " or ,");
+            }
+        }
+        return ret;
+    }
+
+    int64_t readInt()
+    {
+        const std::string w = readWord();
+        if (w == "null")
+        {
+            return ABC::ABCFile::NULL_INT;
+        }
+        const int64_t ret = strtoll(w.c_str(), nullptr, 0);
+        if (ret < ABC::ABCFile::MIN_INT || ret > ABC::ABCFile::MAX_INT)
+        {
+            throw StringException("Int out of bounds");
+        }
+        return ret;
+    }
+
+    uint64_t readUInt()
+    {
+        const std::string w = readWord();
+        if (w == "null")
+        {
+            return ABC::ABCFile::NULL_UINT;
+        }
+        const uint64_t ret = strtoull(w.c_str(), nullptr, 0);
+        if (ret > ABC::ABCFile::MAX_UINT)
+        {
+            throw StringException("UInt out of bounds");
+        }
+        return ret;
+    }
+
+    double readDouble()
+    {
+        const std::string w = readWord();
+        if (w == "null")
+        {
+            return ABC::ABCFile::NULL_DOUBLE;
+        }
+        return strtod(w.c_str(), nullptr);
+    }
+
+    std::string readString()
+    {
+        skipWhitespace();
+        char c = readSymbol();
+        if (c != '"')
+        {
+            std::string word = readWord();
+            if (c == 'n' && word == "ull")
+            {
+                return {};
+            }
+            else
+            {
+                backpedal(1 + word.size());
+                throw StringException("String literal expected");
+            }
+        }
+
+        std::string ret;
+        while (true)
+        {
+            switch (c = readChar())
+            {
+                case '"':
+                    return ret;
+                case '\\':
+                {
+                    switch (c = readChar())
+                    {
+                        case 'n':
+                            ret += '\n';
+                            break;
+                        case 'r':
+                            ret += '\r';
+                            break;
+                        case 'x':
+                        {
+                            char c0 = readChar();
+                            char c1 = readChar();
+                            ret += (char)((fromHex(c0) << 4) | fromHex(c1));
+                        }
+                        break;
+                        default:
+                            ret += c;
+                            break;
+                    }
+                }
+                break;
+                case '\0':
+                    throw StringException("Unexpected null terminator");
+                default:
+                    ret += c;
+                    break;
+            }
+        }
+    }
+
+    ASASM::Namespace readNamespace()
+    {
+        std::string word = readWord();
+        if (word == "null")
+        {
+            return {};
+        }
+
+        ABCType kind = toABCType(word);
+        expectSymbol('(');
+        std::string name = readString();
+        int id           = 0;
+        if (peekChar() == ',')
+        {
+            skipChar();
+            std::string s = readString();
+            if (namespaceLabels.contains(s))
+            {
+                id = namespaceLabels.at(s);
+            }
+            else
+            {
+                id = namespaceLabels[s] = namespaceLabels.size() + 1;
+            }
+        }
+        expectSymbol(')');
+
+        return ASASM::Namespace{kind, std::move(name), id};
+    }
+
+    std::vector<ASASM::Namespace> readNamespaceSet()
+    {
+        return readList<'[', ']', true>([this] { return readNamespace(); });
+    }
+
+    ASASM::Multiname readMultiname()
+    {
+        std::string word = readWord();
+        if (word == "null")
+        {
+            return {};
+        }
+        ASASM::Multiname ret;
+        ret.kind = toABCType(word);
+        expectSymbol('(');
+        switch (ret.kind)
+        {
+            case ABCType::QName:
+            case ABCType::QNameA:
+            {
+                ASASM::Multiname::_QName qname;
+                qname.ns = readNamespace();
+                expectSymbol(',');
+                qname.name = readString();
+                ret.qname(qname);
+            }
+            break;
+            case ABCType::RTQName:
+            case ABCType::RTQNameA:
+                ret.rtqname({readString()});
+                break;
+            case ABCType::RTQNameL:
+            case ABCType::RTQNameLA:
+                ret.rtqnamel({});
+                break;
+            case ABCType::Multiname:
+            case ABCType::MultinameA:
+            {
+                ASASM::Multiname::_Multiname multiname;
+                multiname.name = readString();
+                expectSymbol(',');
+                multiname.nsSet = readNamespaceSet();
+                ret.multiname(multiname);
+            }
+            break;
+            case ABCType::MultinameL:
+            case ABCType::MultinameLA:
+                ret.multinamel({readNamespaceSet()});
+                break;
+            case ABCType::TypeName:
+            {
+                ASASM::Multiname::_Typename Typename;
+                Typename.name()   = readMultiname();
+                Typename.params() = readList<'<', '>', false>([this] { return readMultiname(); });
+                ret.Typename(Typename);
+            }
+            break;
+            default:
+                throw StringException("Unknown Multiname kind");
+        }
+        expectSymbol(')');
+        return ret;
+    }
+
+    std::unordered_map<std::string, std::shared_ptr<ASASM::Class>> classesByID;
+    std::unordered_map<std::string, std::shared_ptr<ASASM::Method>> methodsByID;
+
+    template <typename T>
+    struct Fixup
+    {
+        Position where;
+        std::shared_ptr<T>& ptr;
+        std::string name;
+    };
+    std::vector<Fixup<ASASM::Class>> classFixups;
+    std::vector<Fixup<ASASM::Method>> methodFixups;
+
+    ASASM::Trait readTrait()
+    {
+        ASASM::Trait ret;
+        std::string kind = readWord();
+        auto foundKind   = TraitKindMap.Find(kind.c_str());
+        if (!foundKind)
+        {
+            backpedal(kind.size());
+            throw StringException("Unknown trait kind");
+        }
+        ret.kind = *foundKind;
+        ret.name = readMultiname();
+        switch (ret.kind)
+        {
+            case TraitKind::Slot:
+            case TraitKind::Const:
+                ret.vSlot({});
+                while (true)
+                {
+                    std::string word = readWord();
+                    if (word == "flag")
+                    {
+                        ret.attributes |= readFlag(TraitAttributeMap);
+                    }
+                    else if (word == "slotid")
+                    {
+                        ret.vSlot().slotId = readUInt();
+                    }
+                    else if (word == "type")
+                    {
+                        mustBeNull(ret.vSlot().typeName);
+                        ret.vSlot().typeName = readMultiname();
+                    }
+                    else if (word == "value")
+                    {
+                        ret.vSlot().value = readValue();
+                    }
+                    else if (word == "metadata")
+                    {
+                        ret.metadata.emplace_back(readMetadata());
+                    }
+                    else if (word == "end")
+                    {
+                        return ret;
+                    }
+                    else
+                    {
+                        backpedal(word.size());
+                        throw StringException("Unknown " + kind + " trait field " + word);
+                    }
+                }
+                break;
+            case TraitKind::Class:
+                ret.vClass({});
+                while (true)
+                {
+                    std::string word = readWord();
+                    if (word == "flag")
+                    {
+                        ret.attributes |= readFlag(TraitAttributeMap);
+                    }
+                    else if (word == "slotid")
+                    {
+                        ret.vClass().slotId = readUInt();
+                    }
+                    else if (word == "class")
+                    {
+                        mustBeNull(ret.vClass().vclass);
+                        ret.vClass().vclass = readClass();
+                    }
+                    else if (word == "metadata")
+                    {
+                        ret.metadata.emplace_back(readMetadata());
+                    }
+                    else if (word == "end")
+                    {
+                        return ret;
+                    }
+                    else
+                    {
+                        backpedal(word.size());
+                        throw StringException("Unknown " + kind + " trait field " + word);
+                    }
+                }
+                break;
+            case TraitKind::Function:
+                ret.vFunction({});
+                while (true)
+                {
+                    std::string word = readWord();
+                    if (word == "flag")
+                    {
+                        ret.attributes |= readFlag(TraitAttributeMap);
+                    }
+                    else if (word == "slotid")
+                    {
+                        ret.vFunction().slotId = readUInt();
+                    }
+                    else if (word == "method")
+                    {
+                        mustBeNull(ret.vFunction().vfunction);
+                        ret.vFunction().vfunction = readMethod();
+                    }
+                    else if (word == "metadata")
+                    {
+                        ret.metadata.emplace_back(readMetadata());
+                    }
+                    else if (word == "end")
+                    {
+                        return ret;
+                    }
+                    else
+                    {
+                        backpedal(word.size());
+                        throw StringException("Unknown " + kind + " trait field " + word);
+                    }
+                }
+                break;
+            case TraitKind::Method:
+            case TraitKind::Getter:
+            case TraitKind::Setter:
+                ret.vMethod({});
+                while (true)
+                {
+                    std::string word = readWord();
+                    if (word == "flag")
+                    {
+                        ret.attributes |= readFlag(TraitAttributeMap);
+                    }
+                    else if (word == "dispid")
+                    {
+                        ret.vMethod().dispId = readUInt();
+                    }
+                    else if (word == "method")
+                    {
+                        mustBeNull(ret.vMethod().vmethod);
+                        ret.vMethod().vmethod = readMethod();
+                    }
+                    else if (word == "metadata")
+                    {
+                        ret.metadata.emplace_back(readMetadata());
+                    }
+                    else if (word == "end")
+                    {
+                        return ret;
+                    }
+                    else
+                    {
+                        backpedal(word.size());
+                        throw StringException("Unknown " + kind + " trait field " + word);
+                    }
+                }
+                break;
+            default:
+                throw StringException("Unknown trait kind");
+        }
+    }
+
+    ASASM::Metadata readMetadata()
+    {
+        ASASM::Metadata ret;
+        ret.name = readString();
+        std::vector<std::string> items;
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "item")
+            {
+                items.emplace_back(readString());
+                items.emplace_back(readString());
+            }
+            else if (word == "end")
+            {
+                if (sourceVersion < 2)
+                {
+                    for (size_t i = 0; i < items.size() / 2; i++)
+                    {
+                        ret.data.emplace_back(
+                            std::move(items[i]), std::move(items[i + items.size() / 2]));
+                    }
+                }
+                else
+                {
+                    for (size_t i = 0; i < items.size(); i += 2)
+                    {
+                        ret.data.emplace_back(std::move(items[i]), std::move(items[i + 1]));
+                    }
+                }
+                return ret;
+            }
+            else
+            {
+                throw StringException("Expected 'item' or 'end'");
+            }
+        }
+    }
+
+    std::shared_ptr<ASASM::Method> readMethod()
+    {
+        auto ret = std::make_shared<ASASM::Method>();
+
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "name")
+            {
+                mustBeNull(ret->name);
+                ret->name = readString();
+            }
+            else if (word == "refid")
+            {
+                addUnique<addUniqueMethod>(methodsByID, readString(), ret);
+            }
+            else if (word == "param")
+            {
+                ret->paramTypes.emplace_back(readMultiname());
+            }
+            else if (word == "returns")
+            {
+                mustBeNull(ret->returnType);
+                ret->returnType = readMultiname();
+            }
+            else if (word == "flag")
+            {
+                ret->flags |= readFlag(MethodFlagMap);
+            }
+            else if (word == "optional")
+            {
+                ret->options.emplace_back(readValue());
+            }
+            else if (word == "paramname")
+            {
+                ret->paramNames.emplace_back(readString());
+            }
+            else if (word == "body")
+            {
+                ret->vbody         = readMethodBody();
+                ret->vbody->method = ret;
+            }
+            else if (word == "end")
+            {
+                return ret;
+            }
+            else
+            {
+                throw StringException("Unknown method field " + word);
+            }
+        }
+    }
+
+    ASASM::Instance readInstance()
+    {
+        ASASM::Instance ret;
+        ret.name = readMultiname();
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "extends")
+            {
+                mustBeNull(ret.superName);
+                ret.superName = readMultiname();
+            }
+            else if (word == "implements")
+            {
+                ret.interfaces.emplace_back(readMultiname());
+            }
+            else if (word == "flag")
+            {
+                ret.flags |= readFlag(InstanceFlagMap);
+            }
+            else if (word == "protectedns")
+            {
+                mustBeNull(ret.protectedNs);
+                ret.protectedNs = readNamespace();
+            }
+            else if (word == "iinit")
+            {
+                mustBeNull(ret.iinit);
+                ret.iinit = readMethod();
+            }
+            else if (word == "trait")
+            {
+                ret.traits.emplace_back(readTrait());
+            }
+            else if (word == "end")
+            {
+                static constexpr char iinit[] = "iinit";
+                mustBeSet<iinit>(ret.iinit);
+                return ret;
+            }
+            else
+            {
+                throw StringException("Unknown instance field " + word);
+            }
+        }
+    }
+
+    std::shared_ptr<ASASM::Class> readClass()
+    {
+        auto ret = std::make_shared<ASASM::Class>();
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "refid")
+            {
+                addUnique<addUniqueClass>(classesByID, readString(), ret);
+            }
+            else if (word == "instance")
+            {
+                mustBeNull(ret->instance);
+                ret->instance = readInstance();
+            }
+            else if (word == "cinit")
+            {
+                mustBeNull(ret->cinit);
+                ret->cinit = readMethod();
+            }
+            else if (word == "trait")
+            {
+                ret->traits.emplace_back(readTrait());
+            }
+            else if (word == "end")
+            {
+                static constexpr char cinit[]    = "cinit";
+                static constexpr char instance[] = "instance";
+                mustBeSet<cinit>(ret->cinit);
+                mustBeSet<instance>(ret->instance);
+                return ret;
+            }
+            else
+            {
+                throw StringException("Unknown class field " + word);
+            }
+        }
+    }
+
+    ASASM::Script readScript()
+    {
+        ASASM::Script ret;
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "sinit")
+            {
+                mustBeNull(ret.sinit);
+                ret.sinit = readMethod();
+            }
+            else if (word == "trait")
+            {
+                ret.traits.emplace_back(readTrait());
+            }
+            else if (word == "end")
+            {
+                static constexpr char sinit[] = "sinit";
+                mustBeSet<sinit>(ret.sinit);
+                return ret;
+            }
+            else
+            {
+                backpedal(word.size());
+                throw StringException("Unknown script field " + word);
+            }
+        }
+    }
+
+    ASASM::MethodBody readMethodBody()
+    {
+        std::unordered_map<std::string, uint32_t> labels;
+        ASASM::MethodBody ret;
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "maxstack")
+            {
+                ret.maxStack = std::max<uint32_t>(ret.maxStack, readUInt());
+            }
+            else if (word == "localcount")
+            {
+                ret.localCount = std::max<uint32_t>(ret.localCount, readUInt());
+            }
+            else if (word == "initscopedepth")
+            {
+                ret.initScopeDepth = readUInt();
+            }
+            else if (word == "maxscopedepth")
+            {
+                ret.maxScopeDepth = readUInt();
+            }
+            else if (word == "code")
+            {
+                ret.instructions = readInstructions(labels);
+            }
+            else if (word == "try")
+            {
+                ret.exceptions.emplace_back(readException(labels));
+            }
+            else if (word == "trait")
+            {
+                ret.traits.emplace_back(readTrait());
+            }
+            else if (word == "end")
+            {
+                return ret;
+            }
+            else
+            {
+                backpedal(word.size());
+                throw StringException("Unknown method field " + word);
+            }
+        }
+    }
+
+    ABC::Label parseLabel(
+        const std::string& label, const std::unordered_map<std::string, uint32_t>& labels)
+    {
+        std::string name = label;
+        int offset       = 0;
+        for (size_t i = 0; i < label.size(); i++)
+        {
+            if (label[i] == '-' || label[i] == '+')
+            {
+                name   = label.substr(0, i);
+                offset = atoi(label.c_str() + i + 1);
+                if (label[i] == '-')
+                {
+                    offset = -offset;
+                }
+                break;
+            }
+        }
+
+        if (!labels.contains(name))
+        {
+            backpedal(label.size());
+            throw StringException("Unknown label " + name);
+        }
+
+        return ABC::Label{labels.at(name), offset, 0};
+    }
+
+    std::vector<ASASM::Instruction> readInstructions(
+        std::unordered_map<std::string, uint32_t>& _labels)
+    {
+        std::vector<ASASM::Instruction> ret;
+        struct LocalFixup
+        {
+            Position where;
+            uint32_t ii, ai;
+            std::string name;
+            uint32_t si;
+        };
+        std::vector<LocalFixup> jumpFixups, switchFixups, localClassFixups, localMethodFixups;
+        std::unordered_map<std::string, uint32_t> labels;
+
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "end")
+            {
+                break;
+            }
+            if (peekChar() == ':')
+            {
+                addUnique<addUniqueLabel>(labels, word, uint32_t(ret.size()));
+                skipChar();
+                continue;
+            }
+
+            auto opcode = OPCodeMap.Find(word.c_str());
+            if (!opcode)
+            {
+                backpedal(word.size());
+                throw StringException("Unknown OPCode " + word);
+            }
+
+            ASASM::Instruction instruction;
+            instruction.opcode = *opcode;
+            instruction.arguments.resize(OPCode_Info[(uint8_t)instruction.opcode].second.size());
+            for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size(); i++)
+            {
+                switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                {
+                    case OPCodeArgumentType::Unknown:
+                        throw StringException(
+                            "Don't know how to assemble OP_" +
+                            std::string(OPCode_Info[(uint8_t)instruction.opcode].first));
+
+                    case OPCodeArgumentType::ByteLiteral:
+                        if (sourceVersion < 4)
+                        {
+                            instruction.arguments[i].bytev((uint8_t)readInt());
+                        }
+                        else
+                        {
+                            instruction.arguments[i].bytev((int8_t)readInt());
+                        }
+                        break;
+                    case OPCodeArgumentType::UByteLiteral:
+                        instruction.arguments[i].ubytev(readUInt());
+                        break;
+                    case OPCodeArgumentType::IntLiteral:
+                        instruction.arguments[i].intv(readInt());
+                        break;
+                    case OPCodeArgumentType::UIntLiteral:
+                        instruction.arguments[i].uintv(readUInt());
+                        break;
+
+                    case OPCodeArgumentType::Int:
+                        instruction.arguments[i].intv(readInt());
+                        break;
+                    case OPCodeArgumentType::UInt:
+                        instruction.arguments[i].uintv(readUInt());
+                        break;
+                    case OPCodeArgumentType::Double:
+                        instruction.arguments[i].doublev(readDouble());
+                        break;
+                    case OPCodeArgumentType::String:
+                        instruction.arguments[i].stringv(readString());
+                        break;
+                    case OPCodeArgumentType::Namespace:
+                        instruction.arguments[i].namespacev(readNamespace());
+                        break;
+                    case OPCodeArgumentType::Multiname:
+                        instruction.arguments[i].multinamev(readMultiname());
+                        break;
+                    case OPCodeArgumentType::Class:
+                        instruction.arguments[i].classv({});
+                        localClassFixups.emplace_back(
+                            currentFile->position(), ret.size(), i, readString(), 0);
+                        break;
+                    case OPCodeArgumentType::Method:
+                        instruction.arguments[i].methodv({});
+                        localMethodFixups.emplace_back(
+                            currentFile->position(), ret.size(), i, readString(), 0);
+                        break;
+
+                    case OPCodeArgumentType::JumpTarget:
+                    case OPCodeArgumentType::SwitchDefaultTarget:
+                        instruction.arguments[i].jumpTarget({});
+                        jumpFixups.emplace_back(
+                            currentFile->position(), ret.size(), i, readWord(), 0);
+                        break;
+
+                    case OPCodeArgumentType::SwitchTargets:
+                    {
+                        std::vector<std::string> switchTargetLabels =
+                            readList<'[', ']', false>([this] { return readWord(); });
+                        instruction.arguments[i].switchTargets(
+                            std::vector<ABC::Label>(switchTargetLabels.size()));
+                        for (size_t li = 0; li < switchTargetLabels.size(); li++)
+                        {
+                            switchFixups.emplace_back(
+                                currentFile->position(), ret.size(), i, switchTargetLabels[li], li);
+                        }
+                    }
+                    break;
+                }
+                if (i + 1 < OPCode_Info[(uint8_t)instruction.opcode].second.size())
+                {
+                    expectSymbol(',');
+                }
+            }
+            if (instruction.opcode == OPCode::OP_getlocal && instruction.arguments[0].uintv() < 4)
+            {
+                instruction.opcode =
+                    OPCode(uint8_t(OPCode::OP_getlocal0) + instruction.arguments[0].uintv());
+            }
+            else if (instruction.opcode == OPCode::OP_setlocal &&
+                     instruction.arguments[0].uintv() < 4)
+            {
+                instruction.opcode =
+                    OPCode(uint8_t(OPCode::OP_setlocal0) + instruction.arguments[0].uintv());
+            }
+
+            ret.emplace_back(std::move(instruction));
+        }
+
+        for (const auto& f : jumpFixups)
+        {
+            try
+            {
+                ret[f.ii].arguments[f.ai].jumpTarget(parseLabel(f.name, labels));
+            }
+            catch (std::exception& e)
+            {
+                setFile(f.where.load());
+                throw e;
+            }
+        }
+
+        for (const auto& f : switchFixups)
+        {
+            try
+            {
+                ret[f.ii].arguments[f.ai].switchTargets()[f.si] = parseLabel(f.name, labels);
+            }
+            catch (std::exception& e)
+            {
+                setFile(f.where.load());
+                throw e;
+            }
+        }
+
+        for (const auto& f : localClassFixups)
+        {
+            classFixups.emplace_back(f.where, ret[f.ii].arguments[f.ai].classv(), f.name);
+        }
+        for (const auto& f : localMethodFixups)
+        {
+            methodFixups.emplace_back(f.where, ret[f.ii].arguments[f.ai].methodv(), f.name);
+        }
+
+        _labels = labels;
+        return ret;
+    }
+
+    ASASM::Exception readException(const std::unordered_map<std::string, uint32_t>& labels)
+    {
+        auto readLabel = [this, &labels] {
+            std::string word = readWord();
+            try
+            {
+                return parseLabel(word, labels);
+            }
+            catch (std::exception& e)
+            {
+                backpedal(word.size());
+                throw e;
+            }
+        };
+
+        ASASM::Exception ret;
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "from")
+            {
+                ret.from = readLabel();
+            }
+            else if (word == "to")
+            {
+                ret.to = readLabel();
+            }
+            else if (word == "target")
+            {
+                ret.target = readLabel();
+            }
+            else if (word == "type")
+            {
+                ret.excType = readMultiname();
+            }
+            else if (word == "name")
+            {
+                ret.varName = readMultiname();
+            }
+            else if (word == "end")
+            {
+                return ret;
+            }
+            else
+            {
+                throw StringException("Unknown exception field " + word);
+            }
+        }
+    }
+
+    Assembler(const std::unordered_map<std::string, std::string>& strings) : strings(strings) {}
+
+    ASASM::ASProgram readProgram()
+    {
+        ASASM::ASProgram ret;
+        expectWord("program");
+        while (true)
+        {
+            std::string word = readWord();
+            if (word == "minorversion")
+            {
+                ret.minorVersion = readUInt();
+            }
+            else if (word == "majorversion")
+            {
+                ret.majorVersion = readUInt();
+            }
+            else if (word == "script")
+            {
+                ret.scripts.emplace_back(readScript());
+            }
+            else if (word == "class")
+            {
+                ret.orphanClasses.emplace_back(readClass());
+            }
+            else if (word == "method")
+            {
+                ret.orphanMethods.emplace_back(readMethod());
+            }
+            else if (word == "end")
+            {
+                return ret;
+            }
+            else
+            {
+                backpedal(word.size());
+                throw StringException("Unknown program field " + word);
+            }
+        }
+    }
+
+    std::string context()
+    {
+        std::string ret = currentFile->positionStr() + ": ";
+        for (std::shared_ptr<SourceFile> f = currentFile->parent; f != nullptr; f = f->parent)
+        {
+            ret += "\n\t(included from " + f->positionStr() + ")";
+        }
+        return ret;
+    }
+
+    void applyFixups()
+    {
+        for (const auto& f : classFixups)
+        {
+            if (f.name.empty())
+            {
+                f.ptr = nullptr;
+            }
+            else
+            {
+                if (!classesByID.contains(f.name))
+                {
+                    setFile(f.where.load());
+                    throw StringException("Unknown class refid: " + f.name);
+                }
+                f.ptr = classesByID.at(f.name);
+            }
+        }
+
+        for (const auto& f : methodFixups)
+        {
+            if (f.name.empty())
+            {
+                f.ptr = nullptr;
+            }
+            else
+            {
+                if (!methodsByID.contains(f.name))
+                {
+                    setFile(f.where.load());
+                    throw StringException("Unknown class refid: " + f.name);
+                }
+                f.ptr = methodsByID.at(f.name);
+            }
+        }
+
+        classFixups.clear();
+        methodFixups.clear();
+        classesByID.clear();
+        methodsByID.clear();
+    }
+
+public:
+    static ASASM::ASProgram assemble(const std::unordered_map<std::string, std::string>& strings)
+    {
+        if (!strings.contains("main.asasm"))
+        {
+            throw StringException("Assembly start (main.asasm) not found");
+        }
+
+        Assembler assembler(strings);
+
+        std::shared_ptr<SourceFile> mainFile =
+            std::make_shared<SourceFile>("main.asasm", strings.at("main.asasm"));
+        assembler.pushFile(mainFile);
+
+        try
+        {
+            ASASM::ASProgram ret = assembler.readProgram();
+            assembler.applyFixups();
+            return ret;
+        }
+        catch (std::exception& e)
+        {
+            throw StringException("\n" + assembler.context() + "\n" + e.what());
+        }
+    }
+};
diff --git a/Native/BytecodeEditor/include/BytecodeEditor.hpp b/Native/BytecodeEditor/include/BytecodeEditor.hpp
new file mode 100644
index 0000000..7c0f771
--- /dev/null
+++ b/Native/BytecodeEditor/include/BytecodeEditor.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "SWF/SWFFile.hpp"
+#include "utils/ANEUtils.hpp"
+#include <FlashRuntimeExtensions.h>
+#include <optional>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <variant>
+
+class BytecodeEditor
+{
+private:
+    FREContext ctx;
+
+    std::optional<SWF::SWFFile> currentSWF;
+
+    std::jthread runningTask;
+
+    std::variant<std::monostate, std::string, std::unordered_map<std::string, std::string>,
+        std::vector<uint8_t>>
+        m_taskResult;
+
+public:
+    BytecodeEditor(FREContext ctx) noexcept : ctx(ctx) {}
+
+    FREObject disassemble();
+    FREObject disassembleAsync();
+
+    FREObject assemble(std::unordered_map<std::string, std::string>&& data);
+    FREObject assembleAsync(std::unordered_map<std::string, std::string>&& data);
+
+    void setSWF(SWF::SWFFile&& file) { currentSWF = std::move(file); }
+
+    void cleanup()
+    {
+        if (runningTask.joinable())
+        {
+            runningTask.join();
+        }
+        currentSWF = std::nullopt;
+        m_taskResult = std::monostate{};
+    }
+
+    FREObject taskResult();
+};
diff --git a/Native/BytecodeEditor/include/Disassembler.hpp b/Native/BytecodeEditor/include/Disassembler.hpp
new file mode 100644
index 0000000..c102c4f
--- /dev/null
+++ b/Native/BytecodeEditor/include/Disassembler.hpp
@@ -0,0 +1,884 @@
+#pragma once
+
+#include "ASASM/ASProgram.hpp"
+#include "ASASM/Class.hpp"
+#include "ASASM/Exception.hpp"
+#include "ASASM/Instance.hpp"
+#include "ASASM/Instruction.hpp"
+#include "ASASM/Metadata.hpp"
+#include "ASASM/Method.hpp"
+#include "ASASM/MethodBody.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "ASASM/Script.hpp"
+#include "ASASM/Trait.hpp"
+#include "ASASM/Value.hpp"
+#include "enums/InstanceFlags.hpp"
+#include "enums/MethodFlags.hpp"
+#include "enums/TraitAttribute.hpp"
+#include "utils/RefBuilder.hpp"
+#include "utils/StringBuilder.hpp"
+
+#include <climits>
+#include <cmath>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+class Disassembler
+{
+private:
+    std::unordered_map<std::string, std::string> strings;
+    const ASASM::ASProgram& as;
+
+    RefBuilder refs;
+    bool dumpRaw = true;
+
+    template <typename Callback>
+    void newInclude(
+        StringBuilder& mainsb, std::string_view filename, Callback callback, bool doInline = true)
+    {
+        if (doInline)
+        {
+            StringBuilder sb;
+            callback(sb);
+            strings.insert_or_assign(std::string(filename), sb.str());
+
+            mainsb << "#include ";
+            dumpString(mainsb, filename);
+            mainsb.newLine();
+        }
+        else
+        {
+            callback(mainsb);
+        }
+    }
+
+public:
+    Disassembler(const ASASM::ASProgram& as) : as(as), refs(as) {}
+
+    std::unordered_map<std::string, std::string> disassemble()
+    {
+        refs.run();
+
+        StringBuilder sb;
+
+        sb << "#version 4";
+        sb.newLine();
+
+        sb << "program";
+        sb.indent++;
+        sb.newLine();
+
+        sb << "minorversion " << as.minorVersion;
+        sb.newLine();
+        sb << "majorversion " << as.majorVersion;
+        sb.newLine();
+        sb.newLine();
+
+        for (size_t i = 0; i < as.scripts.size(); i++)
+        {
+            newInclude(sb, refs.scripts.getFilename(&as.scripts[i], "script"),
+                [this, i](StringBuilder& sb) { dumpScript(sb, as.scripts[i], i); });
+        }
+        sb.newLine();
+
+        if (!as.orphanClasses.empty())
+        {
+            sb << "; ============================= Orphan classes ==============================";
+            sb.newLine();
+            sb.newLine();
+
+            for (size_t i = 0; i < as.orphanClasses.size(); i++)
+            {
+                newInclude(sb, refs.objects.getFilename(as.orphanClasses[i].get(), "class"),
+                    [this, i](StringBuilder& sb) { dumpClass(sb, *as.orphanClasses[i]); });
+            }
+            sb.newLine();
+        }
+
+        if (!as.orphanMethods.empty())
+        {
+            sb << "; ============================= Orphan methods ==============================";
+            sb.newLine();
+            sb.newLine();
+
+            for (size_t i = 0; i < as.orphanMethods.size(); i++)
+            {
+                newInclude(sb, refs.objects.getFilename(as.orphanMethods[i].get(), "method"),
+                    [this, i](
+                        StringBuilder& sb) { dumpMethod(sb, *as.orphanMethods[i], "method"); });
+            }
+            sb.newLine();
+        }
+
+        sb.indent--;
+        sb << "end ; program";
+        sb.newLine();
+
+        strings.insert_or_assign(std::string("main.asasm"), sb.str());
+        return std::move(strings);
+    }
+
+    void dumpInt(StringBuilder& sb, int64_t v)
+    {
+        if (v == ABC::ABCFile::NULL_INT)
+            sb << "null";
+        else
+            sb.write(v);
+    }
+
+    void dumpUInt(StringBuilder& sb, uint64_t v)
+    {
+        if (v == ABC::ABCFile::NULL_UINT)
+            sb << "null";
+        else
+            sb.write(v);
+    }
+
+    void dumpDouble(StringBuilder& sb, double v)
+    {
+        if (std::isnan(v)) // v == ABC::ABCFile::NULL_DOUBLE
+        {
+            sb << "null";
+            return;
+        }
+        else if (std::isinf(v))
+        {
+            assert(-INFINITY < 0);
+            if (v < 0)
+            {
+                sb << "-inf";
+            }
+            else
+            {
+                sb << "inf";
+            }
+        }
+        else
+        {
+            std::array<char, 20> formatStr;
+            std::array<std::array<char, 64>, 19> precisions;
+            std::array<int, 19> lengths;
+
+            // Try all precisions of printing from 0-18
+            for (int i = 0; i <= 18; i++)
+            {
+                sprintf(formatStr.data(), "%%.%ig", i);
+                sprintf(precisions[i].data(), formatStr.data(), v);
+
+                lengths[i] = strlen(precisions[i].data());
+            }
+
+            int current      = INT_MAX;
+            int currentIndex = -1;
+            for (int i = 0; i <= 18; i++)
+            {
+                if (current > lengths[i] && std::strtod(precisions[i].data(), nullptr) == v)
+                {
+                    currentIndex = i;
+                    current      = lengths[i];
+                }
+            }
+
+            if (currentIndex != -1)
+            {
+                sb << precisions[currentIndex].data();
+                return;
+            }
+
+            // Otherwise we try hex notation
+
+            sprintf(precisions[0].data(), "%.13a", v);
+            assert(std::strtod(precisions[0].data(), nullptr) == v);
+
+            sb << precisions[0].data();
+        }
+    }
+
+    void dumpString(StringBuilder& sb, std::string_view str, bool emptyIsNull = false)
+    {
+        if (emptyIsNull && (str.size() == 0 || str == ""))
+        {
+            sb << "null";
+            return;
+        }
+        // if (str is null)
+        //   sb ~= "null";
+
+        static constexpr std::array<char, 16> hexDigits{
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+        sb << '"';
+        for (unsigned char c : str)
+        {
+            if (c == '\n')
+            {
+                sb << "\\n";
+            }
+            else if (c == '\r')
+            {
+                sb << "\\r";
+            }
+            else if (c == '\\')
+            {
+                sb << "\\\\";
+            }
+            else if (c == '"')
+            {
+                sb << "\\\"";
+            }
+            else if (c < 0x20)
+            {
+                sb << "\\x" << hexDigits[c / 0x10] << hexDigits[c % 0x10];
+            }
+            else
+            {
+                sb << c;
+            }
+        }
+        sb << '"';
+    }
+
+    void dumpNamespace(StringBuilder& sb, const ASASM::Namespace& ns)
+    {
+        if (ns.kind == ABCType::Void)
+        {
+            sb << "null";
+        }
+        else
+        {
+            sb << *ABCTypeMap.ReverseFind(ns.kind) << '(';
+            dumpString(sb, ns.name);
+            if (refs.hasHomonyms(ns))
+            {
+                sb << ", ";
+                dumpString(sb, refs.namespaces[(uint8_t)ns.kind].getName(ns.id));
+            }
+            sb << ')';
+        }
+    }
+
+    void dumpNamespaceSet(StringBuilder& sb, const ASASM::Namespace* nsSet, size_t size)
+    {
+        if (size == 0)
+        {
+            sb << "null";
+        }
+        else
+        {
+            sb << '[';
+            for (size_t i = 0; i < size; i++)
+            {
+                dumpNamespace(sb, nsSet[i]);
+                if (i < size - 1)
+                    sb << ", ";
+            }
+            sb << ']';
+        }
+    }
+    void dumpNamespaceSet(StringBuilder& sb, const std::vector<ASASM::Namespace>& nsSet)
+    {
+        dumpNamespaceSet(sb, nsSet.data(), nsSet.size());
+    }
+
+    void dumpMultiname(StringBuilder& sb, const ASASM::Multiname& multiname)
+    {
+        if (multiname.kind == ABCType::Void)
+        {
+            sb << "null";
+        }
+        else
+        {
+            sb << *ABCTypeMap.ReverseFind(multiname.kind) << '(';
+            switch (multiname.kind)
+            {
+                case ABCType::QName:
+                case ABCType::QNameA:
+                    dumpNamespace(sb, multiname.qname().ns);
+                    sb << ", ";
+                    dumpString(sb, multiname.qname().name);
+                    break;
+                case ABCType::RTQName:
+                case ABCType::RTQNameA:
+                    dumpString(sb, multiname.rtqname().name);
+                    break;
+                case ABCType::RTQNameL:
+                case ABCType::RTQNameLA:
+                    break;
+                case ABCType::Multiname:
+                case ABCType::MultinameA:
+                    dumpString(sb, multiname.multiname().name);
+                    sb << ", ";
+                    dumpNamespaceSet(sb, multiname.multiname().nsSet);
+                    break;
+                case ABCType::MultinameL:
+                case ABCType::MultinameLA:
+                    dumpNamespaceSet(sb, multiname.multinamel().nsSet);
+                    break;
+                case ABCType::TypeName:
+                    dumpMultiname(sb, multiname.Typename().name());
+                    sb << '<';
+                    for (size_t i = 0; i < multiname.Typename().params().size(); i++)
+                    {
+                        dumpMultiname(sb, multiname.Typename().params()[i]);
+                        if (i < multiname.Typename().params().size() - 1)
+                            sb << ", ";
+                    }
+                    sb << '>';
+                    break;
+                default:
+                    throw StringException("Unknown multiname kind");
+            }
+            sb << ')';
+        }
+    }
+
+    void dumpTraits(
+        StringBuilder& sb, const ASASM::Trait* traits, size_t size, bool inScript = false)
+    {
+        for (size_t i = 0; i < size; i++)
+        {
+            const auto& trait = traits[i];
+
+            sb << "trait " << *TraitKindMap.ReverseFind(trait.kind) << ' ';
+            dumpMultiname(sb, trait.name);
+            if (trait.attributes)
+                dumpFlags(sb, trait.attributes, TraitAttributeMap, true);
+            bool inLine = false;
+            switch (trait.kind)
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    if (trait.vSlot().slotId)
+                    {
+                        sb << " slotid ";
+                        dumpUInt(sb, trait.vSlot().slotId);
+                    }
+                    if (trait.vSlot().typeName.kind != ABCType::Void)
+                    {
+                        sb << " type ";
+                        dumpMultiname(sb, trait.vSlot().typeName);
+                    }
+                    if (trait.vSlot().value.vkind != ABCType::Void)
+                    {
+                        sb << " value ";
+                        dumpValue(sb, trait.vSlot().value);
+                    }
+                    inLine = true;
+                    break;
+                case TraitKind::Class:
+                    if (trait.vClass().slotId)
+                    {
+                        sb << " slotid ";
+                        dumpUInt(sb, trait.vClass().slotId);
+                    }
+                    sb.indent++;
+                    sb.newLine();
+
+                    newInclude(sb, refs.objects.getFilename(trait.vClass().vclass.get(), "class"),
+                        [this, &trait](
+                            StringBuilder& sb) { dumpClass(sb, *trait.vClass().vclass); });
+                    break;
+                case TraitKind::Function:
+                    if (trait.vFunction().slotId)
+                    {
+                        sb << " slotid ";
+                        dumpUInt(sb, trait.vFunction().slotId);
+                    }
+                    sb.indent++;
+                    sb.newLine();
+                    newInclude(
+                        sb, refs.objects.getFilename(trait.vFunction().vfunction.get(), "method"),
+                        [this, &trait](StringBuilder& sb) {
+                            dumpMethod(sb, *trait.vFunction().vfunction, "method");
+                        },
+                        inScript);
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    if (trait.vMethod().dispId)
+                    {
+                        sb << " dispid ";
+                        dumpUInt(sb, trait.vMethod().dispId);
+                    }
+                    sb.indent++;
+                    sb.newLine();
+                    newInclude(
+                        sb, refs.objects.getFilename(trait.vMethod().vmethod.get(), "method"),
+                        [this, &trait](StringBuilder& sb) {
+                            dumpMethod(sb, *trait.vMethod().vmethod, "method");
+                        },
+                        inScript);
+                    break;
+                default:
+                    throw StringException("Unknown trait kind");
+            }
+
+            for (const auto& metadata : trait.metadata)
+            {
+                if (inLine)
+                {
+                    sb.indent++;
+                    sb.newLine();
+                    inLine = false;
+                }
+                dumpMetadata(sb, metadata);
+            }
+
+            if (inLine)
+            {
+                sb << " end";
+                sb.newLine();
+            }
+            else
+            {
+                sb.indent--;
+                sb << "end ; trait";
+                sb.newLine();
+            }
+        }
+    }
+    void dumpTraits(
+        StringBuilder& sb, const std::vector<ASASM::Trait> traits, bool inScript = false)
+    {
+        dumpTraits(sb, traits.data(), traits.size(), inScript);
+    }
+
+    void dumpMetadata(StringBuilder& sb, const ASASM::Metadata& metadata)
+    {
+        sb << "metadata ";
+        dumpString(sb, metadata.name);
+        sb.indent++;
+        sb.newLine();
+        for (const auto& md : metadata.data)
+        {
+            sb << "item ";
+            dumpString(sb, md.first);
+            sb << " ";
+            dumpString(sb, md.second);
+            sb.newLine();
+        }
+        sb.indent--;
+        sb << "end ; metadata";
+        sb.newLine();
+    }
+
+    template <typename FlagMap>
+    void dumpFlags(StringBuilder& sb, uint8_t v, const FlagMap& map, bool oneLine = false)
+    {
+        const auto& entries = map.GetEntries();
+        for (size_t i = 0; i < entries.second; i++)
+        {
+            const auto& entry = entries.first[i];
+            if (v & (uint8_t)entry.second)
+            {
+                sb << (oneLine ? " flag " : "flag ") << entry.first;
+                if (!oneLine)
+                {
+                    sb.newLine();
+                }
+            }
+        }
+    }
+
+    void dumpValue(StringBuilder& sb, const ASASM::Value& value)
+    {
+        sb << *ABCTypeMap.ReverseFind(value.vkind) << '(';
+        switch (value.vkind)
+        {
+            case ABCType::Integer:
+                dumpInt(sb, value.vint());
+                break;
+            case ABCType::UInteger:
+                dumpUInt(sb, value.vuint());
+                break;
+            case ABCType::Double:
+                dumpDouble(sb, value.vdouble());
+                break;
+            case ABCType::Utf8:
+                dumpString(sb, value.vstring());
+                break;
+            case ABCType::Namespace:
+            case ABCType::PackageNamespace:
+            case ABCType::PackageInternalNs:
+            case ABCType::ProtectedNamespace:
+            case ABCType::ExplicitNamespace:
+            case ABCType::StaticProtectedNs:
+            case ABCType::PrivateNamespace:
+                dumpNamespace(sb, value.vnamespace());
+                break;
+            case ABCType::True:
+            case ABCType::False:
+            case ABCType::Null:
+            case ABCType::Undefined:
+                break;
+            default:
+                throw StringException("Unknown type");
+        }
+        sb << ')';
+    }
+
+    void dumpMethod(StringBuilder& sb, const ASASM::Method& method, std::string_view label)
+    {
+        sb << label;
+        sb.indent++;
+        sb.newLine();
+        // if (method.name !is null)
+        // {
+        sb << "name ";
+        dumpString(sb, method.name);
+        sb.newLine();
+        // }
+
+        auto refName = refs.objects.getName(&method);
+        // if (refName)
+        // {
+        sb << "refid ";
+        dumpString(sb, refName);
+        sb.newLine();
+        // }
+
+        for (const auto& type : method.paramTypes)
+        {
+            sb << "param ";
+            dumpMultiname(sb, type);
+            sb.newLine();
+        }
+
+        if (method.returnType.kind != ABCType::Void)
+        {
+            sb << "returns ";
+            dumpMultiname(sb, method.returnType);
+            sb.newLine();
+        }
+
+        dumpFlags(sb, method.flags, MethodFlagMap);
+
+        for (const auto& v : method.options)
+        {
+            sb << "optional ";
+            dumpValue(sb, v);
+            sb.newLine();
+        }
+
+        for (const auto& s : method.paramNames)
+        {
+            sb << "paramname ";
+            dumpString(sb, s, true);
+            sb.newLine();
+        }
+        if (method.vbody)
+        {
+            dumpMethodBody(sb, *method.vbody);
+        }
+        sb.indent--;
+        sb << "end ; method";
+        sb.newLine();
+    }
+
+    void dumpClass(StringBuilder& sb, const ASASM::Class& vclass)
+    {
+        sb << "class";
+        sb.indent++;
+        sb.newLine();
+
+        auto refName = refs.objects.getName(&vclass);
+        // if (refName)
+        // {
+        sb << "refid ";
+        dumpString(sb, refName);
+        sb.newLine();
+        // }
+
+        sb << "instance ";
+        dumpInstance(sb, vclass.instance);
+        dumpMethod(sb, *vclass.cinit, "cinit");
+        dumpTraits(sb, vclass.traits);
+
+        sb.indent--;
+        sb << "end ; class";
+        sb.newLine();
+    }
+
+    void dumpInstance(StringBuilder& sb, const ASASM::Instance& instance)
+    {
+        dumpMultiname(sb, instance.name);
+        sb.indent++;
+        sb.newLine();
+
+        if (instance.superName.kind != ABCType::Void)
+        {
+            sb << "extends ";
+            dumpMultiname(sb, instance.superName);
+            sb.newLine();
+        }
+
+        for (const auto& interface : instance.interfaces)
+        {
+            sb << "implements ";
+            dumpMultiname(sb, interface);
+            sb.newLine();
+        }
+
+        dumpFlags(sb, instance.flags, InstanceFlagMap);
+
+        if (instance.protectedNs.kind != ABCType::Void)
+        {
+            sb << "protectedns ";
+            dumpNamespace(sb, instance.protectedNs);
+            sb.newLine();
+        }
+
+        dumpMethod(sb, *instance.iinit, "iinit");
+        dumpTraits(sb, instance.traits);
+        sb.indent--;
+        sb << "end ; instance";
+        sb.newLine();
+    }
+
+    void dumpScript(StringBuilder& sb, const ASASM::Script& script, uint32_t index)
+    {
+        sb << "script";
+        sb.indent++;
+        sb.newLine();
+
+        dumpMethod(sb, *script.sinit, "sinit");
+        dumpTraits(sb, script.traits, true);
+
+        sb.indent--;
+        sb << "end ; script";
+        sb.newLine();
+    }
+
+    void dumpUIntField(StringBuilder& sb, std::string_view name, uint32_t value)
+    {
+        sb << name << ' ';
+        dumpUInt(sb, value);
+        sb.newLine();
+    }
+
+    void dumpLabel(StringBuilder& sb, const ABC::Label& label)
+    {
+        sb << 'L';
+        sb.write(label.index);
+        if (label.offset != 0)
+        {
+            if (label.offset > 0)
+                sb << '+';
+            sb.write(label.offset);
+        }
+    }
+
+    void dumpMethodBody(StringBuilder& sb, const ASASM::MethodBody& body)
+    {
+        sb << "body";
+        sb.indent++;
+        sb.newLine();
+
+        dumpUIntField(sb, "maxstack", body.maxStack);
+        dumpUIntField(sb, "localcount", body.localCount);
+        dumpUIntField(sb, "initscopedepth", body.initScopeDepth);
+        dumpUIntField(sb, "maxscopedepth", body.maxScopeDepth);
+
+        sb << "code";
+        sb.newLine();
+
+        std::vector<bool> labels(body.instructions.size() + 1);
+        // reserve exception labels
+        for (const auto& e : body.exceptions)
+        {
+            labels[e.from.index] = labels[e.to.index] = labels[e.target.index] = true;
+        }
+
+        sb.indent++;
+        dumpInstructions(sb, body.instructions, labels, body.errors);
+        sb.indent--;
+
+        sb << "end ; code";
+        sb.newLine();
+
+        for (const auto& e : body.exceptions)
+        {
+            sb << "try from ";
+            dumpLabel(sb, e.from);
+            sb << " to ";
+            dumpLabel(sb, e.to);
+            sb << " target ";
+            dumpLabel(sb, e.target);
+            sb << " type ";
+            dumpMultiname(sb, e.excType);
+            sb << " name ";
+            dumpMultiname(sb, e.varName);
+            sb << " end";
+            sb.newLine();
+        }
+
+        dumpTraits(sb, body.traits);
+
+        sb.indent--;
+        sb << "end ; body";
+        sb.newLine();
+        sb.linePrefix = "";
+    }
+
+    void dumpInstructions(StringBuilder& sb, const std::vector<ASASM::Instruction>& instructions,
+        std::vector<bool>& labels, const std::vector<ABC::Error>& errors)
+    {
+        for (const auto& instruction : instructions)
+        {
+            for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size(); i++)
+            {
+                switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                {
+                    case OPCodeArgumentType::JumpTarget:
+                    case OPCodeArgumentType::SwitchDefaultTarget:
+                        labels[instruction.arguments[i].jumpTarget().index] = true;
+                        break;
+                    case OPCodeArgumentType::SwitchTargets:
+                        for (const auto& label : instruction.arguments[i].switchTargets())
+                        {
+                            labels[label.index] = true;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+
+        auto checkLabel = [&](size_t ii) {
+            if (labels[ii])
+            {
+                sb.noIndent();
+                sb << 'L';
+                sb.write(ii);
+                sb << ':';
+                sb.newLine();
+            }
+        };
+
+        std::vector<std::string> iErrors(instructions.size() + 1);
+        for (const auto& error : errors)
+        {
+            iErrors[error.loc.index] = error.message;
+        }
+
+        bool extraNewLine = false;
+        for (size_t ii = 0; ii < instructions.size(); ii++)
+        {
+            const auto& instruction = instructions[ii];
+            if (extraNewLine)
+                sb.newLine();
+            // extraNewLine = newLineAfter[instruction.opcode];
+            checkLabel(ii);
+
+            if (!iErrors[ii].empty())
+            {
+                sb << "; Error: " << iErrors[ii];
+                sb.newLine();
+            }
+
+            if (instruction.opcode == OPCode::OP_raw)
+            {
+                // if (dumpRaw)
+                //  sb << std::ios::hex << "; " << instruction.arguments[0].ubytev() <<
+                //  std::ios::dec;
+                // sb.newLine();
+                continue;
+            }
+
+            sb << OPCode_Info[(uint8_t)instruction.opcode].first;
+
+            const auto& argTypes = OPCode_Info[(uint8_t)instruction.opcode].second;
+            if (argTypes.size() != 0)
+            {
+                sb << ' ';
+                for (size_t i = 0; i < argTypes.size(); i++)
+                {
+                    switch (argTypes[i])
+                    {
+                        case OPCodeArgumentType::Unknown:
+                            throw StringException(std::string("Don't know how to disassemble OP_") +
+                                                  OPCode_Info[(uint8_t)instruction.opcode].first);
+
+                        case OPCodeArgumentType::ByteLiteral:
+                            sb.write((int32_t)instruction.arguments[i].bytev());
+                            break;
+                        case OPCodeArgumentType::UByteLiteral:
+                            sb.write((uint32_t)instruction.arguments[i].ubytev());
+                            break;
+                        case OPCodeArgumentType::IntLiteral:
+                            sb.write(instruction.arguments[i].intv());
+                            break;
+                        case OPCodeArgumentType::UIntLiteral:
+                            sb.write(instruction.arguments[i].uintv());
+                            break;
+
+                        case OPCodeArgumentType::Int:
+                            dumpInt(sb, instruction.arguments[i].intv());
+                            break;
+                        case OPCodeArgumentType::UInt:
+                            dumpUInt(sb, instruction.arguments[i].uintv());
+                            break;
+                        case OPCodeArgumentType::Double:
+                            dumpDouble(sb, instruction.arguments[i].doublev());
+                            break;
+                        case OPCodeArgumentType::String:
+                            dumpString(sb, instruction.arguments[i].stringv());
+                            break;
+                        case OPCodeArgumentType::Namespace:
+                            dumpNamespace(sb, instruction.arguments[i].namespacev());
+                            break;
+                        case OPCodeArgumentType::Multiname:
+                            dumpMultiname(sb, instruction.arguments[i].multinamev());
+                            break;
+                        case OPCodeArgumentType::Class:
+                            // if (instruction.arguments[i].classv is null)
+                            //     sb ~ = "null";
+                            // else
+                            dumpString(
+                                sb, refs.objects.getName(instruction.arguments[i].classv().get()));
+                            break;
+                        case OPCodeArgumentType::Method:
+                            // if (instruction.arguments[i].methodv is null)
+                            //     sb ~ = "null";
+                            // else
+                            dumpString(
+                                sb, refs.objects.getName(instruction.arguments[i].methodv().get()));
+                            break;
+
+                        case OPCodeArgumentType::JumpTarget:
+                        case OPCodeArgumentType::SwitchDefaultTarget:
+                            dumpLabel(sb, instruction.arguments[i].jumpTarget());
+                            break;
+
+                        case OPCodeArgumentType::SwitchTargets:
+                        {
+                            sb << '[';
+                            const auto& targets = instruction.arguments[i].switchTargets();
+                            for (size_t i = 0; i < targets.size(); i++)
+                            {
+                                dumpLabel(sb, targets[i]);
+                                if (i < targets.size() - 1)
+                                {
+                                    sb << ", ";
+                                }
+                            }
+                            sb << ']';
+                        }
+                        break;
+                    }
+                    if (i < argTypes.size() - 1)
+                    {
+                        sb << ", ";
+                    }
+                }
+            }
+            sb.newLine();
+        }
+        checkLabel(instructions.size());
+    }
+};
diff --git a/Native/BytecodeEditor/include/SWF/SWFFile.hpp b/Native/BytecodeEditor/include/SWF/SWFFile.hpp
new file mode 100644
index 0000000..8cd1579
--- /dev/null
+++ b/Native/BytecodeEditor/include/SWF/SWFFile.hpp
@@ -0,0 +1,253 @@
+#pragma once
+
+#include "enums/TagType.hpp"
+#include "utils/StringException.hpp"
+#include <bit>
+#include <cassert>
+#include <filesystem>
+#include <stdint.h>
+#include <vector>
+
+namespace SWF
+{
+    // Note: does not handle compression. The SWF data passed in must be pre-decompressed.
+    // Note: must be compiled for little-endian architectures
+    class SWFFile
+    {
+    public:
+        struct Tag
+        {
+            const uint8_t* data      = nullptr;
+            const uint8_t* patchData = nullptr;
+            size_t patchLength       = 0;
+            size_t patchOffset       = 0;
+            uint32_t length          = 0;
+            TagType type             = TagType::End;
+            bool forceLongLength     = false;
+        };
+        struct Header
+        {
+            char magic[3];
+            uint8_t version;
+            uint32_t fileLength;
+        };
+        static_assert(sizeof(Header) == 8);
+        static_assert(std::endian::native == std::endian::little);
+
+        size_t numAbcTags() const { return abcTags.size(); }
+
+        std::pair<const uint8_t*, size_t> abcData(size_t abcTagIndex = 0) const
+        {
+            const Tag& tag         = abcTag(abcTagIndex);
+            const uint8_t* abcData = tag.data;
+            abcData += 4; // skip flags
+            while (*abcData++)
+                ; // skip name
+            return {abcData, tag.length - (std::distance<const uint8_t*>(tag.data, abcData))};
+        }
+
+        // Note: does not own this data pointer. Data pointer must be valid for the time this
+        // SWFFile is being used.
+        void replaceABCData(const uint8_t* data, size_t length, size_t index = 0)
+        {
+            Tag& tag        = abcTag(index);
+            tag.patchData   = data;
+            tag.patchLength = length;
+
+            const uint8_t* abcData = tag.data;
+            abcData += 4; // skip flags
+            while (*abcData++)
+                ; // skip name
+
+            tag.patchOffset = std::distance<const uint8_t*>(tag.data, abcData);
+        }
+
+        size_t getFullSize() const
+        {
+            size_t ret =
+                sizeof(Header) + frameSizeData.size() + sizeof(frameRate) + sizeof(frameCount);
+            for (const Tag& t : tags)
+            {
+                ret += 2; // Type and small size
+                if (t.patchData != nullptr)
+                {
+                    if (t.patchLength + t.patchOffset >= 0x3F || t.forceLongLength)
+                    {
+                        ret += 4;
+                    }
+                    ret += t.patchLength + t.patchOffset;
+                }
+                else
+                {
+                    if (t.length >= 0x3F || t.forceLongLength)
+                    {
+                        ret += 4;
+                    }
+                    ret += t.length;
+                }
+            }
+
+            return ret;
+        }
+
+        // Storage must be large enough to fit getFullSize() bytes
+        void writeTo(uint8_t* out) const
+        {
+            const uint32_t maxSize = getFullSize();
+            size_t currentPos      = 0;
+            auto writeData         = [out, maxSize, &currentPos](size_t writeSize, const auto* in) {
+                if (writeSize == 0)
+                    return;
+                if (currentPos + writeSize > maxSize)
+                    throw StringException("SWF file write went out of bounds");
+                std::copy(reinterpret_cast<const uint8_t*>(in),
+                    reinterpret_cast<const uint8_t*>(in) + writeSize,
+                    reinterpret_cast<uint8_t*>(out) + currentPos);
+                currentPos += writeSize;
+            };
+
+            writeData(3, header.magic);
+            writeData(1, &header.version);
+            writeData(4, &maxSize);
+
+            writeData(frameSizeData.size(), frameSizeData.data());
+
+            writeData(2, &frameRate);
+            writeData(2, &frameCount);
+
+            auto writeTag = [&writeData, &currentPos](const Tag& tag) {
+                uint16_t rawTagData = uint16_t(tag.type) << 6;
+                if (tag.patchData != nullptr)
+                {
+                    const uint32_t finalLength = tag.patchLength + tag.patchOffset;
+                    if (finalLength >= 0x3F)
+                    {
+                        rawTagData |= 0x3F;
+                        writeData(2, &rawTagData);
+                        writeData(4, &finalLength);
+                    }
+                    else
+                    {
+                        rawTagData |= uint8_t(finalLength);
+                        writeData(2, &rawTagData);
+                    }
+                    writeData(tag.patchOffset, tag.data);
+                    writeData(tag.patchLength, tag.patchData);
+                }
+                else
+                {
+                    if (tag.length >= 0x3F || tag.forceLongLength)
+                    {
+                        rawTagData |= 0x3F;
+                        writeData(2, &rawTagData);
+                        writeData(4, &tag.length);
+                    }
+                    else
+                    {
+                        rawTagData |= uint8_t(tag.length);
+                        writeData(2, &rawTagData);
+                    }
+                    writeData(tag.length, tag.data);
+                }
+            };
+
+            for (const auto& tag : tags)
+            {
+                writeTag(tag);
+            }
+        }
+
+        // SWF must already be decompressed
+        SWFFile(std::vector<uint8_t>&& _data) : data(std::move(_data))
+        {
+            size_t currentPos = 0;
+            auto readData     = [this, &currentPos](size_t readSize, auto* out) {
+                if (currentPos + readSize > data.size())
+                    throw StringException("SWF file read went out of bounds");
+                std::copy(data.begin() + currentPos, data.begin() + currentPos + readSize,
+                    reinterpret_cast<uint8_t*>(out));
+                currentPos += readSize;
+            };
+            readData(3, header.magic);
+            readData(1, &header.version);
+            readData(4, &header.fileLength);
+
+            if (header.fileLength != data.size())
+                throw StringException(
+                    "Header length is larger than the given size. This should not happen!");
+
+            uint8_t rectSize;
+            readData(1, &rectSize);
+            uint32_t nbits  = rectSize >> 3;
+            uint32_t nbytes = ((5 + 4 * nbits) + 7) / 8;
+            currentPos--;
+            frameSizeData.resize(nbytes);
+            readData(nbytes, frameSizeData.data());
+
+            readData(2, &frameRate);
+            readData(2, &frameCount);
+
+            auto readTag = [this, &readData, &currentPos] {
+                Tag ret;
+                uint16_t rawTagData;
+                readData(2, &rawTagData);
+                ret.type   = TagType(rawTagData >> 6);
+                ret.length = rawTagData & 0x3F;
+                if (ret.length == 0x3F)
+                {
+                    readData(4, &ret.length);
+                    if (ret.length < 0x3F)
+                    {
+                        ret.forceLongLength = true;
+                    }
+                }
+                if (currentPos + ret.length > data.size())
+                    throw StringException("SWF tag read went out of bounds");
+                ret.data = data.data() + currentPos;
+                currentPos += ret.length;
+                return ret;
+            };
+
+            while (currentPos < data.size())
+            {
+                Tag tag = readTag();
+                if (tag.type == TagType::DoABC2)
+                {
+                    abcTags.emplace_back(tags.size());
+                }
+                tags.emplace_back(std::move(tag));
+            }
+        }
+
+    private:
+        const Tag& abcTag(size_t index = 0) const
+        {
+            if (index >= abcTags.size())
+            {
+                throw StringException("ABC Tag " + std::to_string(index + 1) +
+                                      " does not exist (there are " +
+                                      std::to_string(abcTags.size()) + ")");
+            }
+            return tags[abcTags[index]];
+        }
+
+        Tag& abcTag(size_t index = 0)
+        {
+            if (index >= abcTags.size())
+            {
+                throw StringException("ABC Tag " + std::to_string(index + 1) +
+                                      " does not exist (there are " +
+                                      std::to_string(abcTags.size()) + ")");
+            }
+            return tags[abcTags[index]];
+        }
+
+        std::vector<uint8_t> data;
+
+        Header header;
+        uint16_t frameRate, frameCount;
+        std::vector<uint8_t> frameSizeData;
+        std::vector<Tag> tags;
+        std::vector<size_t> abcTags;
+    };
+}
diff --git a/Native/BytecodeEditor/include/enums/ABCType.hpp b/Native/BytecodeEditor/include/enums/ABCType.hpp
new file mode 100644
index 0000000..f822580
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/ABCType.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "utils/BidirectionalMap.hpp"
+#include <array>
+#include <stdint.h>
+#include <string_view>
+
+enum class ABCType : uint8_t
+{
+    Void               = 0x00, // not actually interned
+    Undefined          = Void,
+    Utf8               = 0x01,
+    Decimal            = 0x02,
+    Integer            = 0x03,
+    UInteger           = 0x04,
+    PrivateNamespace   = 0x05,
+    Double             = 0x06,
+    QName              = 0x07, // ns::name, const ns, const name
+    Namespace          = 0x08,
+    Multiname          = 0x09, //[ns...]::name, const [ns...], const name
+    False              = 0x0A,
+    True               = 0x0B,
+    Null               = 0x0C,
+    QNameA             = 0x0D, // @ns::name, const ns, const name
+    MultinameA         = 0x0E, // @[ns...]::name, const [ns...], const name
+    RTQName            = 0x0F, // ns::name, var ns, const name
+    RTQNameA           = 0x10, // @ns::name, var ns, const name
+    RTQNameL           = 0x11, // ns::[name], var ns, var name
+    RTQNameLA          = 0x12, // @ns::[name], var ns, var name
+    Namespace_Set      = 0x15, // a set of namespaces - used by multiname
+    PackageNamespace   = 0x16, // a namespace that was derived from a package
+    PackageInternalNs  = 0x17, // a namespace that had no uri
+    ProtectedNamespace = 0x18,
+    ExplicitNamespace  = 0x19,
+    StaticProtectedNs  = 0x1A,
+    MultinameL         = 0x1B,
+    MultinameLA        = 0x1C,
+    TypeName           = 0x1D
+};
+
+constexpr inline BidirectionalMap ABCTypeMap = MakeCStringMap(std::equal_to<>(), "Void",
+    ABCType::Void, "Utf8", ABCType::Utf8, "Decimal", ABCType::Decimal, "Integer", ABCType::Integer,
+    "UInteger", ABCType::UInteger, "PrivateNamespace", ABCType::PrivateNamespace, "Double",
+    ABCType::Double, "QName", ABCType::QName, "Namespace", ABCType::Namespace, "Multiname",
+    ABCType::Multiname, "False", ABCType::False, "True", ABCType::True, "Null", ABCType::Null,
+    "QNameA", ABCType::QNameA, "MultinameA", ABCType::MultinameA, "RTQName", ABCType::RTQName,
+    "RTQNameA", ABCType::RTQNameA, "RTQNameL", ABCType::RTQNameL, "RTQNameLA", ABCType::RTQNameLA,
+    "Namespace_Set", ABCType::Namespace_Set, "PackageNamespace", ABCType::PackageNamespace,
+    "PackageInternalNs", ABCType::PackageInternalNs, "ProtectedNamespace",
+    ABCType::ProtectedNamespace, "ExplicitNamespace", ABCType::ExplicitNamespace,
+    "StaticProtectedNs", ABCType::StaticProtectedNs, "MultinameL", ABCType::MultinameL,
+    "MultinameLA", ABCType::MultinameLA, "TypeName", ABCType::TypeName);
diff --git a/Native/BytecodeEditor/include/enums/InstanceFlags.hpp b/Native/BytecodeEditor/include/enums/InstanceFlags.hpp
new file mode 100644
index 0000000..9c40cb7
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/InstanceFlags.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "utils/BidirectionalMap.hpp"
+#include <stdint.h>
+
+enum class InstanceFlags : uint8_t
+{
+    Sealed = 0x01, // The class is sealed: properties can not be dynamically added to instances of
+                   // the class.
+    Final       = 0x02, // The class is final: it cannot be a base class for any other class.
+    Interface   = 0x04, // The class is an interface.
+    ProtectedNs = 0x08, // The class uses its protected namespace and the protectedNs field is
+                        // present in the interface_info structure.
+};
+
+constexpr inline BidirectionalMap InstanceFlagMap = MakeCStringMap(std::equal_to<>(), "SEALED",
+    InstanceFlags::Sealed, "FINAL", InstanceFlags::Final, "INTERFACE", InstanceFlags::Interface,
+    "PROTECTEDNS", InstanceFlags::ProtectedNs);
diff --git a/Native/BytecodeEditor/include/enums/MethodFlags.hpp b/Native/BytecodeEditor/include/enums/MethodFlags.hpp
new file mode 100644
index 0000000..1fb6b12
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/MethodFlags.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "utils/BidirectionalMap.hpp"
+#include <stdint.h>
+
+enum class MethodFlags : uint8_t
+{
+    NEED_ARGUMENTS = 0x01,  // Suggests to the run-time that an "arguments" object (as specified by
+                            // the ActionScript 3.0 Language Reference) be created. Must not be used
+                            // together with NEED_REST. See Chapter 3.
+    NEED_ACTIVATION = 0x02, // Must be set if this method uses the newactivation opcode.
+    NEED_REST = 0x04,    // This flag creates an ActionScript 3.0 rest arguments array. Must not be
+                         // used with NEED_ARGUMENTS. See Chapter 3.
+    HAS_OPTIONAL = 0x08, // Must be set if this method has optional parameters and the options field
+                         // is present in this method_info structure.
+    SET_DXNS = 0x40,     // Must be set if this method uses the dxns or dxnslate opcodes.
+    HAS_PARAM_NAMES =
+        0x80 // Must be set when the param_names field is present in this method_info structure.
+};
+
+constexpr inline BidirectionalMap MethodFlagMap = MakeCStringMap(std::equal_to<>(),
+    "NEED_ARGUMENTS", MethodFlags::NEED_ARGUMENTS, "NEED_ACTIVATION", MethodFlags::NEED_ACTIVATION,
+    "NEED_REST", MethodFlags::NEED_REST, "HAS_OPTIONAL", MethodFlags::HAS_OPTIONAL, "SET_DXNS",
+    MethodFlags::SET_DXNS, "HAS_PARAM_NAMES", MethodFlags::HAS_PARAM_NAMES);
diff --git a/Native/BytecodeEditor/include/enums/OPCode.hpp b/Native/BytecodeEditor/include/enums/OPCode.hpp
new file mode 100644
index 0000000..334c719
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/OPCode.hpp
@@ -0,0 +1,488 @@
+#pragma once
+
+#include "enums/OPCodeArgumentType.hpp"
+#include "utils/BidirectionalMap.hpp"
+#include "utils/SmallTrivialVector.hpp"
+#include <array>
+#include <functional>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+enum class OPCode : uint8_t
+{
+    OP_raw                = 0x00, /// Used internally by RABCDAsm
+    OP_bkpt               = 0x01,
+    OP_nop                = 0x02,
+    OP_throw              = 0x03,
+    OP_getsuper           = 0x04,
+    OP_setsuper           = 0x05,
+    OP_dxns               = 0x06,
+    OP_dxnslate           = 0x07,
+    OP_kill               = 0x08,
+    OP_label              = 0x09,
+    OP_ifnlt              = 0x0C,
+    OP_ifnle              = 0x0D,
+    OP_ifngt              = 0x0E,
+    OP_ifnge              = 0x0F,
+    OP_jump               = 0x10,
+    OP_iftrue             = 0x11,
+    OP_iffalse            = 0x12,
+    OP_ifeq               = 0x13,
+    OP_ifne               = 0x14,
+    OP_iflt               = 0x15,
+    OP_ifle               = 0x16,
+    OP_ifgt               = 0x17,
+    OP_ifge               = 0x18,
+    OP_ifstricteq         = 0x19,
+    OP_ifstrictne         = 0x1A,
+    OP_lookupswitch       = 0x1B,
+    OP_pushwith           = 0x1C,
+    OP_popscope           = 0x1D,
+    OP_nextname           = 0x1E,
+    OP_hasnext            = 0x1F,
+    OP_pushnull           = 0x20,
+    OP_pushundefined      = 0x21,
+    OP_pushuninitialized  = 0x22,
+    OP_nextvalue          = 0x23,
+    OP_pushbyte           = 0x24,
+    OP_pushshort          = 0x25,
+    OP_pushtrue           = 0x26,
+    OP_pushfalse          = 0x27,
+    OP_pushnan            = 0x28,
+    OP_pop                = 0x29,
+    OP_dup                = 0x2A,
+    OP_swap               = 0x2B,
+    OP_pushstring         = 0x2C,
+    OP_pushint            = 0x2D,
+    OP_pushuint           = 0x2E,
+    OP_pushdouble         = 0x2F,
+    OP_pushscope          = 0x30,
+    OP_pushnamespace      = 0x31,
+    OP_hasnext2           = 0x32,
+    OP_pushdecimal        = 0x33,
+    OP_pushdnan           = 0x34,
+    OP_li8                = 0x35,
+    OP_li16               = 0x36,
+    OP_li32               = 0x37,
+    OP_lf32               = 0x38,
+    OP_lf64               = 0x39,
+    OP_si8                = 0x3A,
+    OP_si16               = 0x3B,
+    OP_si32               = 0x3C,
+    OP_sf32               = 0x3D,
+    OP_sf64               = 0x3E,
+    OP_newfunction        = 0x40,
+    OP_call               = 0x41,
+    OP_construct          = 0x42,
+    OP_callmethod         = 0x43,
+    OP_callstatic         = 0x44,
+    OP_callsuper          = 0x45,
+    OP_callproperty       = 0x46,
+    OP_returnvoid         = 0x47,
+    OP_returnvalue        = 0x48,
+    OP_constructsuper     = 0x49,
+    OP_constructprop      = 0x4A,
+    OP_callsuperid        = 0x4B,
+    OP_callproplex        = 0x4C,
+    OP_callinterface      = 0x4D,
+    OP_callsupervoid      = 0x4E,
+    OP_callpropvoid       = 0x4F,
+    OP_sxi1               = 0x50,
+    OP_sxi8               = 0x51,
+    OP_sxi16              = 0x52,
+    OP_applytype          = 0x53,
+    OP_newobject          = 0x55,
+    OP_newarray           = 0x56,
+    OP_newactivation      = 0x57,
+    OP_newclass           = 0x58,
+    OP_getdescendants     = 0x59,
+    OP_newcatch           = 0x5A,
+    OP_deldescendants     = 0x5B,
+    OP_findpropstrict     = 0x5D,
+    OP_findproperty       = 0x5E,
+    OP_finddef            = 0x5F,
+    OP_getlex             = 0x60,
+    OP_setproperty        = 0x61,
+    OP_getlocal           = 0x62,
+    OP_setlocal           = 0x63,
+    OP_getglobalscope     = 0x64,
+    OP_getscopeobject     = 0x65,
+    OP_getproperty        = 0x66,
+    OP_getpropertylate    = 0x67,
+    OP_initproperty       = 0x68,
+    OP_setpropertylate    = 0x69,
+    OP_deleteproperty     = 0x6A,
+    OP_deletepropertylate = 0x6B,
+    OP_getslot            = 0x6C,
+    OP_setslot            = 0x6D,
+    OP_getglobalslot      = 0x6E,
+    OP_setglobalslot      = 0x6F,
+    OP_convert_s          = 0x70,
+    OP_esc_xelem          = 0x71,
+    OP_esc_xattr          = 0x72,
+    OP_convert_i          = 0x73,
+    OP_convert_u          = 0x74,
+    OP_convert_d          = 0x75,
+    OP_convert_b          = 0x76,
+    OP_convert_o          = 0x77,
+    OP_checkfilter        = 0x78,
+    OP_convert_m          = 0x79,
+    OP_convert_m_p        = 0x7A,
+    OP_coerce             = 0x80,
+    OP_coerce_b           = 0x81,
+    OP_coerce_a           = 0x82,
+    OP_coerce_i           = 0x83,
+    OP_coerce_d           = 0x84,
+    OP_coerce_s           = 0x85,
+    OP_astype             = 0x86,
+    OP_astypelate         = 0x87,
+    OP_coerce_u           = 0x88,
+    OP_coerce_o           = 0x89,
+    OP_negate_p           = 0x8F,
+    OP_negate             = 0x90,
+    OP_increment          = 0x91,
+    OP_inclocal           = 0x92,
+    OP_decrement          = 0x93,
+    OP_declocal           = 0x94,
+    OP_typeof             = 0x95,
+    OP_not                = 0x96,
+    OP_bitnot             = 0x97,
+    OP_concat             = 0x9A,
+    OP_add_d              = 0x9B,
+    OP_increment_p        = 0x9C,
+    OP_inclocal_p         = 0x9D,
+    OP_decrement_p        = 0x9E,
+    OP_declocal_p         = 0x9F,
+    OP_add                = 0xA0,
+    OP_subtract           = 0xA1,
+    OP_multiply           = 0xA2,
+    OP_divide             = 0xA3,
+    OP_modulo             = 0xA4,
+    OP_lshift             = 0xA5,
+    OP_rshift             = 0xA6,
+    OP_urshift            = 0xA7,
+    OP_bitand             = 0xA8,
+    OP_bitor              = 0xA9,
+    OP_bitxor             = 0xAA,
+    OP_equals             = 0xAB,
+    OP_strictequals       = 0xAC,
+    OP_lessthan           = 0xAD,
+    OP_lessequals         = 0xAE,
+    OP_greaterthan        = 0xAF,
+    OP_greaterequals      = 0xB0,
+    OP_instanceof         = 0xB1,
+    OP_istype             = 0xB2,
+    OP_istypelate         = 0xB3,
+    OP_in                 = 0xB4,
+    OP_add_p              = 0xB5,
+    OP_subtract_p         = 0xB6,
+    OP_multiply_p         = 0xB7,
+    OP_divide_p           = 0xB8,
+    OP_modulo_p           = 0xB9,
+    OP_increment_i        = 0xC0,
+    OP_decrement_i        = 0xC1,
+    OP_inclocal_i         = 0xC2,
+    OP_declocal_i         = 0xC3,
+    OP_negate_i           = 0xC4,
+    OP_add_i              = 0xC5,
+    OP_subtract_i         = 0xC6,
+    OP_multiply_i         = 0xC7,
+    OP_getlocal0          = 0xD0,
+    OP_getlocal1          = 0xD1,
+    OP_getlocal2          = 0xD2,
+    OP_getlocal3          = 0xD3,
+    OP_setlocal0          = 0xD4,
+    OP_setlocal1          = 0xD5,
+    OP_setlocal2          = 0xD6,
+    OP_setlocal3          = 0xD7,
+    OP_debug              = 0xEF,
+    OP_debugline          = 0xF0,
+    OP_debugfile          = 0xF1,
+    OP_bkptline           = 0xF2,
+    OP_timestamp          = 0xF3
+};
+
+constexpr inline std::array<std::pair<const char*, SmallTrivialVector<OPCodeArgumentType, 4>>, 256>
+    OPCode_Info = {{
+        /* 0x00 */ {"db", {OPCodeArgumentType::UByteLiteral}},
+        /* 0x01 */ {"bkpt", {OPCodeArgumentType::Unknown}},
+        /* 0x02 */ {"nop", {}},
+        /* 0x03 */ {"throw", {}},
+        /* 0x04 */ {"getsuper", {OPCodeArgumentType::Multiname}},
+        /* 0x05 */ {"setsuper", {OPCodeArgumentType::Multiname}},
+        /* 0x06 */ {"dxns", {OPCodeArgumentType::String}},
+        /* 0x07 */ {"dxnslate", {}},
+        /* 0x08 */ {"kill", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x09 */ {"label", {}},
+        /* 0x0A */ {"0x0A", {OPCodeArgumentType::Unknown}},
+        /* 0x0B */ {"0x0B", {OPCodeArgumentType::Unknown}},
+        /* 0x0C */ {"ifnlt", {OPCodeArgumentType::JumpTarget}},
+        /* 0x0D */ {"ifnle", {OPCodeArgumentType::JumpTarget}},
+        /* 0x0E */ {"ifngt", {OPCodeArgumentType::JumpTarget}},
+        /* 0x0F */ {"ifnge", {OPCodeArgumentType::JumpTarget}},
+        /* 0x10 */ {"jump", {OPCodeArgumentType::JumpTarget}},
+        /* 0x11 */ {"iftrue", {OPCodeArgumentType::JumpTarget}},
+        /* 0x12 */ {"iffalse", {OPCodeArgumentType::JumpTarget}},
+        /* 0x13 */ {"ifeq", {OPCodeArgumentType::JumpTarget}},
+        /* 0x14 */ {"ifne", {OPCodeArgumentType::JumpTarget}},
+        /* 0x15 */ {"iflt", {OPCodeArgumentType::JumpTarget}},
+        /* 0x16 */ {"ifle", {OPCodeArgumentType::JumpTarget}},
+        /* 0x17 */ {"ifgt", {OPCodeArgumentType::JumpTarget}},
+        /* 0x18 */ {"ifge", {OPCodeArgumentType::JumpTarget}},
+        /* 0x19 */ {"ifstricteq", {OPCodeArgumentType::JumpTarget}},
+        /* 0x1A */ {"ifstrictne", {OPCodeArgumentType::JumpTarget}},
+        /* 0x1B */
+        {"lookupswitch",
+            {OPCodeArgumentType::SwitchDefaultTarget, OPCodeArgumentType::SwitchTargets}},
+        /* 0x1C */ {"pushwith", {}},
+        /* 0x1D */ {"popscope", {}},
+        /* 0x1E */ {"nextname", {}},
+        /* 0x1F */ {"hasnext", {}},
+        /* 0x20 */ {"pushnull", {}},
+        /* 0x21 */ {"pushundefined", {}},
+        /* 0x22 */ {"pushuninitialized", {OPCodeArgumentType::Unknown}},
+        /* 0x23 */ {"nextvalue", {}},
+        /* 0x24 */ {"pushbyte", {OPCodeArgumentType::ByteLiteral}},
+        /* 0x25 */ {"pushshort", {OPCodeArgumentType::IntLiteral}},
+        /* 0x26 */ {"pushtrue", {}},
+        /* 0x27 */ {"pushfalse", {}},
+        /* 0x28 */ {"pushnan", {}},
+        /* 0x29 */ {"pop", {}},
+        /* 0x2A */ {"dup", {}},
+        /* 0x2B */ {"swap", {}},
+        /* 0x2C */ {"pushstring", {OPCodeArgumentType::String}},
+        /* 0x2D */ {"pushint", {OPCodeArgumentType::Int}},
+        /* 0x2E */ {"pushuint", {OPCodeArgumentType::UInt}},
+        /* 0x2F */ {"pushdouble", {OPCodeArgumentType::Double}},
+        /* 0x30 */ {"pushscope", {}},
+        /* 0x31 */ {"pushnamespace", {OPCodeArgumentType::Namespace}},
+        /* 0x32 */
+        {"hasnext2", {OPCodeArgumentType::UIntLiteral, OPCodeArgumentType::UIntLiteral}},
+        /* 0x33 */ {"pushdecimal", {OPCodeArgumentType::Unknown}},
+        /* 0x34 */ {"pushdnan", {OPCodeArgumentType::Unknown}},
+        /* 0x35 */ {"li8", {}},
+        /* 0x36 */ {"li16", {}},
+        /* 0x37 */ {"li32", {}},
+        /* 0x38 */ {"lf32", {}},
+        /* 0x39 */ {"lf64", {}},
+        /* 0x3A */ {"si8", {}},
+        /* 0x3B */ {"si16", {}},
+        /* 0x3C */ {"si32", {}},
+        /* 0x3D */ {"sf32", {}},
+        /* 0x3E */ {"sf64", {}},
+        /* 0x3F */ {"0x3F", {OPCodeArgumentType::Unknown}},
+        /* 0x40 */ {"newfunction", {OPCodeArgumentType::Method}},
+        /* 0x41 */ {"call", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x42 */ {"construct", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x43 */
+        {"callmethod", {OPCodeArgumentType::UIntLiteral, OPCodeArgumentType::UIntLiteral}},
+        /* 0x44 */
+        {"callstatic", {OPCodeArgumentType::Method, OPCodeArgumentType::UIntLiteral}},
+        /* 0x45 */
+        {"callsuper", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x46 */
+        {"callproperty", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x47 */ {"returnvoid", {}},
+        /* 0x48 */ {"returnvalue", {}},
+        /* 0x49 */ {"constructsuper", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x4A */
+        {"constructprop", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x4B */ {"callsuperid", {OPCodeArgumentType::Unknown}},
+        /* 0x4C */
+        {"callproplex", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x4D */ {"callinterface", {OPCodeArgumentType::Unknown}},
+        /* 0x4E */
+        {"callsupervoid", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x4F */
+        {"callpropvoid", {OPCodeArgumentType::Multiname, OPCodeArgumentType::UIntLiteral}},
+        /* 0x50 */ {"sxi1", {}},
+        /* 0x51 */ {"sxi8", {}},
+        /* 0x52 */ {"sxi16", {}},
+        /* 0x53 */ {"applytype", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x54 */ {"0x54", {OPCodeArgumentType::Unknown}},
+        /* 0x55 */ {"newobject", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x56 */ {"newarray", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x57 */ {"newactivation", {}},
+        /* 0x58 */ {"newclass", {OPCodeArgumentType::Class}},
+        /* 0x59 */ {"getdescendants", {OPCodeArgumentType::Multiname}},
+        /* 0x5A */ {"newcatch", {OPCodeArgumentType::UIntLiteral}}, // ExceptionInfo index
+        /* 0x5B */ {"deldescendants", {OPCodeArgumentType::Unknown}},
+        /* 0x5C */ {"0x5C", {OPCodeArgumentType::Unknown}},
+        /* 0x5D */ {"findpropstrict", {OPCodeArgumentType::Multiname}},
+        /* 0x5E */ {"findproperty", {OPCodeArgumentType::Multiname}},
+        /* 0x5F */ {"finddef", {OPCodeArgumentType::Multiname}},
+        /* 0x60 */ {"getlex", {OPCodeArgumentType::Multiname}},
+        /* 0x61 */ {"setproperty", {OPCodeArgumentType::Multiname}},
+        /* 0x62 */ {"getlocal", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x63 */ {"setlocal", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x64 */ {"getglobalscope", {}},
+        /* 0x65 */ {"getscopeobject", {OPCodeArgumentType::UByteLiteral}},
+        /* 0x66 */ {"getproperty", {OPCodeArgumentType::Multiname}},
+        /* 0x67 */ {"getpropertylate", {}},
+        /* 0x68 */ {"initproperty", {OPCodeArgumentType::Multiname}},
+        /* 0x69 */ {"setpropertylate", {}},
+        /* 0x6A */ {"deleteproperty", {OPCodeArgumentType::Multiname}},
+        /* 0x6B */ {"deletepropertylate", {}},
+        /* 0x6C */ {"getslot", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x6D */ {"setslot", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x6E */ {"getglobalslot", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x6F */ {"setglobalslot", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x70 */ {"convert_s", {}},
+        /* 0x71 */ {"esc_xelem", {}},
+        /* 0x72 */ {"esc_xattr", {}},
+        /* 0x73 */ {"convert_i", {}},
+        /* 0x74 */ {"convert_u", {}},
+        /* 0x75 */ {"convert_d", {}},
+        /* 0x76 */ {"convert_b", {}},
+        /* 0x77 */ {"convert_o", {}},
+        /* 0x78 */ {"checkfilter", {}},
+        /* 0x79 */ {"convert_m", {OPCodeArgumentType::Unknown}},
+        /* 0x7A */ {"convert_m_p", {OPCodeArgumentType::Unknown}},
+        /* 0x7B */ {"0x7B", {OPCodeArgumentType::Unknown}},
+        /* 0x7C */ {"0x7C", {OPCodeArgumentType::Unknown}},
+        /* 0x7D */ {"0x7D", {OPCodeArgumentType::Unknown}},
+        /* 0x7E */ {"0x7E", {OPCodeArgumentType::Unknown}},
+        /* 0x7F */ {"0x7F", {OPCodeArgumentType::Unknown}},
+        /* 0x80 */ {"coerce", {OPCodeArgumentType::Multiname}},
+        /* 0x81 */ {"coerce_b", {}},
+        /* 0x82 */ {"coerce_a", {}},
+        /* 0x83 */ {"coerce_i", {}},
+        /* 0x84 */ {"coerce_d", {}},
+        /* 0x85 */ {"coerce_s", {}},
+        /* 0x86 */ {"astype", {OPCodeArgumentType::Multiname}},
+        /* 0x87 */ {"astypelate", {}},
+        /* 0x88 */ {"coerce_u", {OPCodeArgumentType::Unknown}},
+        /* 0x89 */ {"coerce_o", {OPCodeArgumentType::Unknown}},
+        /* 0x8A */ {"0x8A", {OPCodeArgumentType::Unknown}},
+        /* 0x8B */ {"0x8B", {OPCodeArgumentType::Unknown}},
+        /* 0x8C */ {"0x8C", {OPCodeArgumentType::Unknown}},
+        /* 0x8D */ {"0x8D", {OPCodeArgumentType::Unknown}},
+        /* 0x8E */ {"0x8E", {OPCodeArgumentType::Unknown}},
+        /* 0x8F */ {"negate_p", {OPCodeArgumentType::Unknown}},
+        /* 0x90 */ {"negate", {}},
+        /* 0x91 */ {"increment", {}},
+        /* 0x92 */ {"inclocal", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x93 */ {"decrement", {}},
+        /* 0x94 */ {"declocal", {OPCodeArgumentType::UIntLiteral}},
+        /* 0x95 */ {"typeof", {}},
+        /* 0x96 */ {"not", {}},
+        /* 0x97 */ {"bitnot", {}},
+        /* 0x98 */ {"0x98", {OPCodeArgumentType::Unknown}},
+        /* 0x99 */ {"0x99", {OPCodeArgumentType::Unknown}},
+        /* 0x9A */ {"concat", {OPCodeArgumentType::Unknown}},
+        /* 0x9B */ {"add_d", {OPCodeArgumentType::Unknown}},
+        /* 0x9C */ {"increment_p", {OPCodeArgumentType::Unknown}},
+        /* 0x9D */ {"inclocal_p", {OPCodeArgumentType::Unknown}},
+        /* 0x9E */ {"decrement_p", {OPCodeArgumentType::Unknown}},
+        /* 0x9F */ {"declocal_p", {OPCodeArgumentType::Unknown}},
+        /* 0xA0 */ {"add", {}},
+        /* 0xA1 */ {"subtract", {}},
+        /* 0xA2 */ {"multiply", {}},
+        /* 0xA3 */ {"divide", {}},
+        /* 0xA4 */ {"modulo", {}},
+        /* 0xA5 */ {"lshift", {}},
+        /* 0xA6 */ {"rshift", {}},
+        /* 0xA7 */ {"urshift", {}},
+        /* 0xA8 */ {"bitand", {}},
+        /* 0xA9 */ {"bitor", {}},
+        /* 0xAA */ {"bitxor", {}},
+        /* 0xAB */ {"equals", {}},
+        /* 0xAC */ {"strictequals", {}},
+        /* 0xAD */ {"lessthan", {}},
+        /* 0xAE */ {"lessequals", {}},
+        /* 0xAF */ {"greaterthan", {}},
+        /* 0xB0 */ {"greaterequals", {}},
+        /* 0xB1 */ {"instanceof", {}},
+        /* 0xB2 */ {"istype", {OPCodeArgumentType::Multiname}},
+        /* 0xB3 */ {"istypelate", {}},
+        /* 0xB4 */ {"in", {}},
+        /* 0xB5 */ {"add_p", {OPCodeArgumentType::Unknown}},
+        /* 0xB6 */ {"subtract_p", {OPCodeArgumentType::Unknown}},
+        /* 0xB7 */ {"multiply_p", {OPCodeArgumentType::Unknown}},
+        /* 0xB8 */ {"divide_p", {OPCodeArgumentType::Unknown}},
+        /* 0xB9 */ {"modulo_p", {OPCodeArgumentType::Unknown}},
+        /* 0xBA */ {"0xBA", {OPCodeArgumentType::Unknown}},
+        /* 0xBB */ {"0xBB", {OPCodeArgumentType::Unknown}},
+        /* 0xBC */ {"0xBC", {OPCodeArgumentType::Unknown}},
+        /* 0xBD */ {"0xBD", {OPCodeArgumentType::Unknown}},
+        /* 0xBE */ {"0xBE", {OPCodeArgumentType::Unknown}},
+        /* 0xBF */ {"0xBF", {OPCodeArgumentType::Unknown}},
+        /* 0xC0 */ {"increment_i", {}},
+        /* 0xC1 */ {"decrement_i", {}},
+        /* 0xC2 */ {"inclocal_i", {OPCodeArgumentType::UIntLiteral}},
+        /* 0xC3 */ {"declocal_i", {OPCodeArgumentType::UIntLiteral}},
+        /* 0xC4 */ {"negate_i", {}},
+        /* 0xC5 */ {"add_i", {}},
+        /* 0xC6 */ {"subtract_i", {}},
+        /* 0xC7 */ {"multiply_i", {}},
+        /* 0xC8 */ {"0xC8", {OPCodeArgumentType::Unknown}},
+        /* 0xC9 */ {"0xC9", {OPCodeArgumentType::Unknown}},
+        /* 0xCA */ {"0xCA", {OPCodeArgumentType::Unknown}},
+        /* 0xCB */ {"0xCB", {OPCodeArgumentType::Unknown}},
+        /* 0xCC */ {"0xCC", {OPCodeArgumentType::Unknown}},
+        /* 0xCD */ {"0xCD", {OPCodeArgumentType::Unknown}},
+        /* 0xCE */ {"0xCE", {OPCodeArgumentType::Unknown}},
+        /* 0xCF */ {"0xCF", {OPCodeArgumentType::Unknown}},
+        /* 0xD0 */ {"getlocal0", {}},
+        /* 0xD1 */ {"getlocal1", {}},
+        /* 0xD2 */ {"getlocal2", {}},
+        /* 0xD3 */ {"getlocal3", {}},
+        /* 0xD4 */ {"setlocal0", {}},
+        /* 0xD5 */ {"setlocal1", {}},
+        /* 0xD6 */ {"setlocal2", {}},
+        /* 0xD7 */ {"setlocal3", {}},
+        /* 0xD8 */ {"0xD8", {OPCodeArgumentType::Unknown}},
+        /* 0xD9 */ {"0xD9", {OPCodeArgumentType::Unknown}},
+        /* 0xDA */ {"0xDA", {OPCodeArgumentType::Unknown}},
+        /* 0xDB */ {"0xDB", {OPCodeArgumentType::Unknown}},
+        /* 0xDC */ {"0xDC", {OPCodeArgumentType::Unknown}},
+        /* 0xDD */ {"0xDD", {OPCodeArgumentType::Unknown}},
+        /* 0xDE */ {"0xDE", {OPCodeArgumentType::Unknown}},
+        /* 0xDF */ {"0xDF", {OPCodeArgumentType::Unknown}},
+        /* 0xE0 */ {"0xE0", {OPCodeArgumentType::Unknown}},
+        /* 0xE1 */ {"0xE1", {OPCodeArgumentType::Unknown}},
+        /* 0xE2 */ {"0xE2", {OPCodeArgumentType::Unknown}},
+        /* 0xE3 */ {"0xE3", {OPCodeArgumentType::Unknown}},
+        /* 0xE4 */ {"0xE4", {OPCodeArgumentType::Unknown}},
+        /* 0xE5 */ {"0xE5", {OPCodeArgumentType::Unknown}},
+        /* 0xE6 */ {"0xE6", {OPCodeArgumentType::Unknown}},
+        /* 0xE7 */ {"0xE7", {OPCodeArgumentType::Unknown}},
+        /* 0xE8 */ {"0xE8", {OPCodeArgumentType::Unknown}},
+        /* 0xE9 */ {"0xE9", {OPCodeArgumentType::Unknown}},
+        /* 0xEA */ {"0xEA", {OPCodeArgumentType::Unknown}},
+        /* 0xEB */ {"0xEB", {OPCodeArgumentType::Unknown}},
+        /* 0xEC */ {"0xEC", {OPCodeArgumentType::Unknown}},
+        /* 0xED */ {"0xED", {OPCodeArgumentType::Unknown}},
+        /* 0xEE */ {"0xEE", {OPCodeArgumentType::Unknown}},
+        /* 0xEF */
+        {"debug", {OPCodeArgumentType::UByteLiteral, OPCodeArgumentType::String,
+                      OPCodeArgumentType::UByteLiteral, OPCodeArgumentType::UIntLiteral}},
+        /* 0xF0 */ {"debugline", {OPCodeArgumentType::UIntLiteral}},
+        /* 0xF1 */ {"debugfile", {OPCodeArgumentType::String}},
+        /* 0xF2 */ {"bkptline", {OPCodeArgumentType::Unknown}},
+        /* 0xF3 */ {"timestamp", {OPCodeArgumentType::Unknown}},
+        /* 0xF4 */ {"0xF4", {OPCodeArgumentType::Unknown}},
+        /* 0xF5 */ {"0xF5", {OPCodeArgumentType::Unknown}},
+        /* 0xF6 */ {"0xF6", {OPCodeArgumentType::Unknown}},
+        /* 0xF7 */ {"0xF7", {OPCodeArgumentType::Unknown}},
+        /* 0xF8 */ {"0xF8", {OPCodeArgumentType::Unknown}},
+        /* 0xF9 */ {"0xF9", {OPCodeArgumentType::Unknown}},
+        /* 0xFA */ {"0xFA", {OPCodeArgumentType::Unknown}},
+        /* 0xFB */ {"0xFB", {OPCodeArgumentType::Unknown}},
+        /* 0xFC */ {"0xFC", {OPCodeArgumentType::Unknown}},
+        /* 0xFD */ {"0xFD", {OPCodeArgumentType::Unknown}},
+        /* 0xFE */ {"0xFE", {OPCodeArgumentType::Unknown}},
+        /* 0xFF */ {"0xFF", {OPCodeArgumentType::Unknown}},
+    }};
+
+constexpr inline BidirectionalMap OPCodeMap = std::invoke(
+    []
+    {
+        std::array<std::pair<const char*, OPCode>, 256> entries{};
+        for (size_t i = 0; i < 256; i++)
+        {
+            entries[i] = {OPCode_Info[i].first, OPCode(i)};
+        }
+        return BidirectionalMap(entries, cstringcomp(), std::equal_to<>());
+    });
diff --git a/Native/BytecodeEditor/include/enums/OPCodeArgumentType.hpp b/Native/BytecodeEditor/include/enums/OPCodeArgumentType.hpp
new file mode 100644
index 0000000..2289c51
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/OPCodeArgumentType.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+enum class OPCodeArgumentType
+{
+    Unknown,
+
+    ByteLiteral,
+    UByteLiteral,
+    IntLiteral,
+    UIntLiteral,
+
+    Int,
+    UInt,
+    Double,
+    String,
+    Namespace,
+    Multiname,
+    Class,
+    Method,
+
+    JumpTarget,
+    SwitchDefaultTarget,
+    SwitchTargets
+};
diff --git a/Native/BytecodeEditor/include/enums/TagType.hpp b/Native/BytecodeEditor/include/enums/TagType.hpp
new file mode 100644
index 0000000..eef6085
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/TagType.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+enum class TagType
+{
+    End                          = 0,
+    ShowFrame                    = 1,
+    DefineShape                  = 2,
+    FreeCharacter                = 3,
+    PlaceObject                  = 4,
+    RemoveObject                 = 5,
+    DefineBits                   = 6,
+    DefineButton                 = 7,
+    JPEGTables                   = 8,
+    SetBackgroundColor           = 9,
+    DefineFont                   = 10,
+    DefineText                   = 11,
+    DoAction                     = 12,
+    DefineFontInfo               = 13,
+    DefineSound                  = 14,
+    StartSound                   = 15,
+    DefineButtonSound            = 17,
+    SoundStreamHead              = 18,
+    SoundStreamBlock             = 19,
+    DefineBitsLossless           = 20,
+    DefineBitsJPEG2              = 21,
+    DefineShape2                 = 22,
+    DefineButtonCxform           = 23,
+    Protect                      = 24,
+    PathsArePostScript           = 25,
+    PlaceObject2                 = 26,
+    RemoveObject2                = 28,
+    DefineShape3                 = 32,
+    DefineText2                  = 33,
+    DefineButton2                = 34,
+    DefineBitsJPEG3              = 35,
+    DefineBitsLossless2          = 36,
+    DefineSprite                 = 39,
+    ProductInfo                  = 41,
+    FrameLabel                   = 43,
+    SoundStreamHead2             = 45,
+    DefineMorphShape             = 46,
+    DefineFont2                  = 48,
+    DefineEditText               = 37,
+    ExportAssets                 = 56,
+    ImportAssets                 = 57,
+    EnableDebugger               = 58,
+    DoInitAction                 = 59,
+    DefineVideoStream            = 60,
+    VideoFrame                   = 61,
+    DefineFontInfo2              = 62,
+    DebugID                      = 63,
+    EnableDebugger2              = 64,
+    ScriptLimits                 = 65,
+    SetTabIndex                  = 66,
+    FileAttributes               = 69,
+    PlaceObject3                 = 70,
+    ImportAssets2                = 71,
+    DoABC                        = 72,
+    DefineFontAlignZones         = 73,
+    CSMTextSettings              = 74,
+    DefineFont3                  = 75,
+    SymbolClass                  = 76,
+    Metadata                     = 77,
+    DefineScalingGrid            = 78,
+    DoABC2                       = 82,
+    DefineShape4                 = 83,
+    DefineMorphShape2            = 84,
+    DefineSceneAndFrameLabelData = 86,
+    DefineBinaryData             = 87,
+    DefineFontName               = 88,
+    DefineFont4                  = 91
+};
diff --git a/Native/BytecodeEditor/include/enums/TraitAttribute.hpp b/Native/BytecodeEditor/include/enums/TraitAttribute.hpp
new file mode 100644
index 0000000..d8646c5
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/TraitAttribute.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "utils/BidirectionalMap.hpp"
+#include <stdint.h>
+
+enum class TraitAttribute : uint8_t
+{
+    Final    = 1,
+    Override = 2,
+    Metadata = 4
+};
+
+constexpr inline BidirectionalMap TraitAttributeMap =
+    MakeCStringMap(std::equal_to<>(), "FINAL", TraitAttribute::Final, "OVERRIDE",
+        TraitAttribute::Override, "METADATA", TraitAttribute::Metadata);
diff --git a/Native/BytecodeEditor/include/enums/TraitKind.hpp b/Native/BytecodeEditor/include/enums/TraitKind.hpp
new file mode 100644
index 0000000..8793596
--- /dev/null
+++ b/Native/BytecodeEditor/include/enums/TraitKind.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "utils/BidirectionalMap.hpp"
+#include <stdint.h>
+
+enum class TraitKind : uint8_t
+{
+    Slot     = 0,
+    Method   = 1,
+    Getter   = 2,
+    Setter   = 3,
+    Class    = 4,
+    Function = 5,
+    Const    = 6
+};
+
+constexpr inline BidirectionalMap TraitKindMap =
+    MakeCStringMap(std::equal_to<>(), "slot", TraitKind::Slot, "method", TraitKind::Method,
+        "getter", TraitKind::Getter, "setter", TraitKind::Setter, "class", TraitKind::Class,
+        "function", TraitKind::Function, "const", TraitKind::Const);
diff --git a/Native/BytecodeEditor/include/utils/ANEUtils.hpp b/Native/BytecodeEditor/include/utils/ANEUtils.hpp
new file mode 100644
index 0000000..3073a4d
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/ANEUtils.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <FlashRuntimeExtensions.h>
+
+#include <string>
+#include <string_view>
+
+#define FAIL_RETURN(x) return x
+
+#define DO_OR_FAIL_NULL(x)                                                                         \
+    if (x != FRE_OK)                                                                               \
+    FAIL_RETURN(nullptr)
+
+#define FAIL_RESULT(message, result)                                                               \
+    do                                                                                             \
+    {                                                                                              \
+        FREObject strThrow;                                                                        \
+        DO_OR_FAIL_NULL(FREString(std::to_string(int32_t(result)) + ": " + message, &strThrow));   \
+        FAIL_RETURN(strThrow);                                                                     \
+    } while (false)
+
+#define FAIL(message)                                                                              \
+    do                                                                                             \
+    {                                                                                              \
+        FREObject strThrow;                                                                        \
+        DO_OR_FAIL_NULL(FREString(message, &strThrow));                                            \
+        FAIL_RETURN(strThrow);                                                                     \
+    } while (false)
+
+#define DO_OR_FAIL(message, x)                                                                     \
+    do                                                                                             \
+    {                                                                                              \
+        if (FREResult res = x; res != FRE_OK)                                                      \
+        {                                                                                          \
+            FAIL_RESULT(message, res);                                                             \
+        }                                                                                          \
+    } while (false)
+
+inline FREResult FREString(std::string_view v, FREObject* res) noexcept
+{
+    return FRENewObjectFromUTF8(v.size(), (const uint8_t*)v.data(), res);
+}
diff --git a/Native/BytecodeEditor/include/utils/BidirectionalMap.hpp b/Native/BytecodeEditor/include/utils/BidirectionalMap.hpp
new file mode 100644
index 0000000..ef15f4f
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/BidirectionalMap.hpp
@@ -0,0 +1,224 @@
+#pragma once
+
+#include <array>
+#include <functional>
+#include <optional>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+// Note: both Key and Value must have a default constructor
+// Note: KeyComparator and ValueComparator must act similarly to std::equal_to
+template <typename K, typename V, size_t Size, typename KC = std::equal_to<>,
+    typename VC = std::equal_to<>>
+class BidirectionalMap
+{
+    static_assert(Size > 0);
+
+private:
+    template <size_t ArraySize>
+    constexpr void populate(const std::pair<K, V>* data)
+    {
+        static_assert(ArraySize <= Size && ArraySize > 0);
+
+        for (size_t i = 0; i < ArraySize; i++)
+            this->entries[i] = data[i];
+
+        if constexpr (ArraySize < Size)
+        {
+            for (size_t i = ArraySize; i < Size; i++)
+                this->entries[i] = {Key(), Value()};
+        }
+    }
+
+public:
+    using Key             = std::remove_cvref_t<K>;
+    using Value           = std::remove_cvref_t<V>;
+    using KeyComparator   = std::remove_cvref_t<KC>;
+    using ValueComparator = std::remove_cvref_t<VC>;
+
+    using Entry = std::pair<Key, Value>;
+
+    BidirectionalMap() = delete;
+
+    template <size_t ArraySize>
+    constexpr BidirectionalMap(
+        const std::pair<K, V> (&inEntries)[ArraySize], KC kc = KC{}, VC vc = VC{})
+        : entries(), populated(ArraySize), kc(kc), vc(vc)
+    {
+        populate<ArraySize>(inEntries);
+    }
+
+    template <size_t ArraySize>
+    constexpr BidirectionalMap(
+        const std::array<std::pair<K, V>, ArraySize>(&inEntries), KC kc = KC{}, VC vc = VC{})
+        : entries(), populated(ArraySize), kc(kc), vc(vc)
+    {
+        populate<ArraySize>(inEntries.data());
+    }
+
+    constexpr BidirectionalMap(const std::pair<K, V> (&inEntries)[Size], KC kc = KC{}, VC vc = VC{})
+        : entries(), populated(Size), kc(kc), vc(vc)
+    {
+        populate<Size>(inEntries);
+    }
+
+    constexpr BidirectionalMap(
+        const std::array<std::pair<K, V>, Size>(&inEntries), KC kc = KC{}, VC vc = VC{})
+        : entries(), populated(Size), kc(kc), vc(vc)
+    {
+        populate<Size>(inEntries.data());
+    }
+
+    constexpr std::optional<Value> Find(const Key& search) const
+    {
+        for (size_t i = 0; i < this->populated; ++i)
+        {
+            if (kc(this->entries[i].first, search))
+            {
+                return this->entries[i].second;
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    constexpr std::optional<Key> ReverseFind(const Value& search) const
+    {
+        for (size_t i = 0; i < this->populated; ++i)
+        {
+            if (vc(this->entries[i].second, search))
+            {
+                return this->entries[i].first;
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    constexpr std::pair<const Entry*, size_t> GetEntries() const
+    {
+        return {entries.data(), this->populated};
+    }
+
+private:
+    std::array<Entry, Size> entries;
+    const size_t populated;
+    [[no_unique_address]] KeyComparator kc;
+    [[no_unique_address]] ValueComparator vc;
+};
+
+template <typename A, typename B, typename... Args>
+struct CheckArgs
+{
+private:
+    using CheckArgs2 = CheckArgs<Args...>;
+
+    static constexpr bool KeyConvertible =
+        std::is_convertible_v<std::remove_cvref_t<A>,
+            std::remove_cvref_t<typename CheckArgs2::AType>> ||
+        std::is_convertible_v<std::remove_cvref_t<typename CheckArgs2::AType>,
+            std::remove_cvref_t<A>>;
+    static constexpr bool ValueConvertible =
+        std::is_convertible_v<std::remove_cvref_t<B>,
+            std::remove_cvref_t<typename CheckArgs2::BType>> ||
+        std::is_convertible_v<std::remove_cvref_t<typename CheckArgs2::BType>,
+            std::remove_cvref_t<B>>;
+
+public:
+    static constexpr bool value = KeyConvertible && ValueConvertible && CheckArgs2::value;
+
+    using AType = std::conditional_t<sizeof...(Args) == 0, A,
+        std::conditional_t<std::is_convertible_v<std::remove_cvref_t<typename CheckArgs2::AType>,
+                               std::remove_cvref_t<A>>,
+            std::remove_cvref_t<A>, std::remove_cvref_t<typename CheckArgs2::AType>>>;
+    using BType = std::conditional_t<sizeof...(Args) == 0, B,
+        std::conditional_t<std::is_convertible_v<std::remove_cvref_t<typename CheckArgs2::BType>,
+                               std::remove_cvref_t<B>>,
+            std::remove_cvref_t<B>, std::remove_cvref_t<typename CheckArgs2::BType>>>;
+};
+
+template <typename A, typename B>
+struct CheckArgs<A, B>
+{
+    static constexpr bool value = true;
+    using AType                 = std::remove_cvref_t<A>;
+    using BType                 = std::remove_cvref_t<B>;
+};
+
+template <typename KeyComparator, typename ValueComparator, typename... Args>
+requires(sizeof...(Args) % 2 == 0) && (sizeof...(Args) > 0) &&
+    (CheckArgs<Args...>::value) constexpr auto MakeMapWithComparators(
+        KeyComparator kc, ValueComparator vc, Args... args)
+{
+    using check = CheckArgs<Args...>;
+
+    auto setArgs = []<typename K, typename V, size_t Size>(
+                       std::array<std::pair<K, V>, Size>& addTo, Args... args)
+    {
+        auto setArgsRef = []<typename A, typename B, typename... InnerArgs>(
+            auto& me, std::array<std::pair<K, V>, Size>& addTo, A key, B val, InnerArgs... args)
+        {
+            size_t index        = Size - (sizeof...(InnerArgs) + 2) / 2;
+            addTo[index].first  = key;
+            addTo[index].second = val;
+
+            if constexpr (sizeof...(InnerArgs) != 0)
+            {
+                me(me, addTo, std::forward<InnerArgs>(args)...);
+            }
+        };
+        setArgsRef(setArgsRef, addTo, args...);
+    };
+
+    std::array<std::pair<typename check::AType, typename check::BType>, sizeof...(Args) / 2>
+        entries{};
+
+    setArgs(entries, std::forward<Args>(args)...);
+
+    return BidirectionalMap<typename check::AType, typename check::BType, sizeof...(Args) / 2,
+        KeyComparator, ValueComparator>{entries, kc, vc};
+}
+
+// Works for all types with operator == defined
+template <typename... Args>
+requires(sizeof...(Args) % 2 == 0) && (sizeof...(Args) > 0) &&
+    (CheckArgs<Args...>::value) constexpr auto MakeMap(Args... args)
+{
+    return MakeMapWithComparators(std::equal_to<>(), std::equal_to<>(), args...);
+}
+
+struct cstringcomp
+{
+    constexpr bool operator()(const char* a, const char* b) const
+    {
+        size_t idx = 0;
+        while (a[idx] != '\0' && b[idx] != '\0')
+        {
+            if (a[idx] != b[idx])
+            {
+                return false;
+            }
+            idx++;
+        }
+
+        if ((a[idx] == '\0') != (b[idx] == '\0'))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    constexpr bool operator()(const char* a, std::string_view b) const { return a == b; }
+
+    constexpr bool operator()(std::string_view b, const char* a) const { return a == b; }
+};
+
+template <typename ValueComparator = std::equal_to<>, typename... Args>
+requires(sizeof...(Args) % 2 == 0) && (sizeof...(Args) > 0) && (CheckArgs<Args...>::value) &&
+    (std::is_same_v<typename CheckArgs<Args...>::AType, const char*>)constexpr auto MakeCStringMap(
+        ValueComparator vc = ValueComparator(), Args... args)
+{
+    return MakeMapWithComparators(cstringcomp(), vc, args...);
+}
diff --git a/Native/BytecodeEditor/include/utils/RefBuilder.hpp b/Native/BytecodeEditor/include/utils/RefBuilder.hpp
new file mode 100644
index 0000000..48e59e8
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/RefBuilder.hpp
@@ -0,0 +1,1035 @@
+#pragma once
+
+#include "ASASM/ASTraitsVisitor.hpp"
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include "enums/ABCType.hpp"
+#include "utils/StringUtils.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <ctype.h>
+#include <stdio.h>
+#include <unordered_map>
+#include <vector>
+
+bool nsSimilar(const ASASM::Namespace& ns1, const ASASM::Namespace& ns2)
+{
+    if (ns1.kind == ABCType::PrivateNamespace || ns2.kind == ABCType::PrivateNamespace)
+        return ns1.kind == ns2.kind && ns1.id == ns2.id;
+    // ignore ns kind in other cases
+    return ns1.name == ns2.name;
+}
+
+class RefBuilder : public ASASM::ASTraitsVisitor
+{
+private:
+    std::array<std::unordered_map<std::string, std::unordered_map<uint32_t, bool>>,
+        ABCTypeMap.GetEntries().second>
+        homonyms;
+
+#ifndef NDEBUG
+    bool homonymsBuilt = false;
+#endif
+
+public:
+    bool hasHomonyms(const ASASM::Namespace& ns) const
+    {
+        return homonyms[(uint8_t)ns.kind].contains(ns.name) &&
+               homonyms[(uint8_t)ns.kind].at(ns.name).size() > 1;
+    }
+
+    void addHomonym(const ASASM::Namespace& ns)
+    {
+        assert(!homonymsBuilt);
+        homonyms[(uint8_t)ns.kind][ns.name][ns.id] = true;
+    }
+
+    /// Represents a link in a "context chain", which represents the context in which an object
+    /// is encountered. The common root of contexts is used to build ref strings, namespace
+    /// labels, file paths etc. Expansion is recursive and delayed until decompilation (an
+    /// object may be encountered inside a private namespace, all contexts of which are unknown
+    /// until the whole program is scanned).
+    struct ContextItem
+    {
+        friend class ::RefBuilder;
+        enum class Type
+        {
+            Multiname, /// An ASProgram.Multiname (may be a private namespace, etc.)
+            String,    /// Fixed string
+            Group      /// Multiple ContextItem[]s (which are expanded and the common root is taken
+                       /// as the result)
+        };
+        struct StrData
+        {
+            std::string str;
+            bool filenameSuffix;
+            bool operator==(const StrData& other) const = default;
+        };
+        struct GroupData
+        {
+            std::vector<ContextItem> group;
+            std::string groupFallback;
+            bool operator==(const GroupData& other) const = default;
+        };
+        struct Segment
+        {
+            char delim;
+            std::string str;
+            bool operator==(const Segment& other) const = default;
+        };
+
+    private:
+        mutable bool expanding = false;
+        std::variant<ASASM::Multiname, StrData, GroupData> data;
+
+    public:
+        Type type;
+
+        std::vector<ContextItem> reduceGroup(const RefBuilder& refs) const
+        {
+            assert(type == Type::Group);
+
+            std::vector<std::vector<ContextItem>> contexts;
+            for (const auto& context : std::get<GroupData>(data).group)
+            {
+                contexts.emplace_back(ContextItem::expand(refs, {context}));
+            }
+
+            std::vector<ContextItem> context;
+            if (!contexts.empty())
+            {
+                context = contexts[0];
+                for (size_t i = 1; i < contexts.size(); i++)
+                {
+                    context = contextRoot(context, contexts[i]);
+                }
+            }
+            if (context.empty())
+            {
+                context = {ContextItem(std::get<GroupData>(data).groupFallback)};
+            }
+            return context;
+        }
+
+        std::vector<Segment> toSegments(const RefBuilder& refs, bool filename) const
+        {
+            switch (type)
+            {
+                case Type::Multiname:
+                {
+                    const ASASM::Multiname& multiname = std::get<ASASM::Multiname>(data);
+                    assert(multiname.kind == ABCType::QName);
+
+                    const auto& ns     = multiname.qname().ns;
+                    const auto& nsName = ns.name;
+
+                    // if (refs.hasHomonyms(ns))
+                    //     nsName += "#" + std::to_string(ns.id);
+                    if (!nsName.empty())
+                    {
+                        if (!multiname.qname().name.empty())
+                        {
+                            return {Segment('/', nsName),
+                                Segment(filename ? '/' : ':', multiname.qname().name)};
+                        }
+                        else
+                        {
+                            return {Segment('/', nsName)};
+                        }
+                    }
+                    else
+                    {
+                        if (!multiname.qname().name.empty())
+                        {
+                            return {Segment('/', multiname.qname().name)};
+                        }
+                        else
+                        {
+                            throw StringException("Unreachable area in toSegments");
+                        }
+                    }
+                }
+                case Type::String:
+                    return {
+                        Segment((filename && std::get<StrData>(data).filenameSuffix) ? '.' : '/',
+                            std::get<StrData>(data).str)};
+                case Type::Group:
+                {
+                    std::vector<Segment> segments;
+                    for (const auto& context : reduceGroup(refs))
+                    {
+                        std::vector<Segment> tmp = context.toSegments(refs, filename);
+                        segments.insert(segments.end(), tmp.begin(), tmp.end());
+                    }
+                    return segments;
+                }
+                default:
+                    throw StringException("Unreachable area in toSegments");
+            }
+        }
+
+        static std::vector<ContextItem> expand(
+            const RefBuilder& refs, const std::vector<ContextItem>& context)
+        {
+            std::vector<ContextItem> newContext;
+            for (const auto& c : context)
+            {
+                std::vector<ContextItem> add = c.expand(refs);
+                if (!add.empty())
+                {
+                    newContext.insert(newContext.end(), add.begin(), add.end());
+                }
+            }
+            return newContext;
+        }
+
+        std::vector<ContextItem> expand(const RefBuilder& refs) const
+        {
+            if (expanding)
+            {
+                switch (type)
+                {
+                    case Type::String:
+                        assert(false);
+                    case Type::Multiname:
+                        return {*this};
+                    case Type::Group:
+                        return {ContextItem(std::get<GroupData>(data).groupFallback)};
+                }
+            }
+
+            assert(!expanding);
+            expanding = true;
+
+            switch (type)
+            {
+                case Type::Multiname:
+                {
+                    auto& multiname = std::get<ASASM::Multiname>(data);
+                    switch (multiname.kind)
+                    {
+                        case ABCType::QName:
+                        {
+                            const auto& ns = multiname.qname().ns;
+                            if (ns.kind == ABCType::PrivateNamespace)
+                            {
+                                auto context = refs.namespaces[(uint8_t)ns.kind].getContext(
+                                    refs, (uint32_t)ns.id);
+                                if (!multiname.qname().name.empty())
+                                {
+                                    context.emplace_back(multiname.qname().name);
+                                }
+                                expanding = false;
+                                return context;
+                            }
+                        }
+                        break;
+                        case ABCType::Multiname:
+                            expanding = false;
+                            return !multiname.multiname().name.empty()
+                                       ? std::vector<ContextItem>{ContextItem(
+                                             multiname.multiname().name)}
+                                       : std::vector<ContextItem>{};
+                        default:
+#ifndef NDEBUG
+                            assert(false);
+#else
+                            break;
+#endif
+                    }
+                }
+
+                case Type::String:
+                    break;
+                case Type::Group:
+                    expanding = false;
+                    return reduceGroup(refs);
+            }
+            expanding = false;
+            return {*this};
+        }
+
+        ContextItem(const ASASM::Multiname& m) : type(Type::Multiname), data(m) {}
+        ContextItem(const std::string& s, bool filenameSuffix = false)
+            : type(Type::String), data(StrData{s, filenameSuffix})
+        {
+        }
+        ContextItem(const std::vector<ContextItem>& group, const std::string& groupFallback)
+            : type(Type::Group), data(GroupData{group, groupFallback})
+        {
+        }
+
+        bool operator==(const ContextItem&) const = default;
+
+        static bool similar(const ContextItem& l, const ContextItem& r)
+        {
+            if (l.type != r.type)
+                return false;
+            switch (l.type)
+            {
+                case Type::String:
+                    return std::get<StrData>(l.data).str == std::get<StrData>(r.data).str;
+                case Type::Multiname:
+                    assert(std::get<ASASM::Multiname>(l.data).kind == ABCType::QName &&
+                           std::get<ASASM::Multiname>(r.data).kind == ABCType::QName);
+                    if (std::get<ASASM::Multiname>(l.data).qname().name !=
+                        std::get<ASASM::Multiname>(r.data).qname().name)
+                        return false;
+                    return nsSimilar(std::get<ASASM::Multiname>(l.data).qname().ns,
+                        std::get<ASASM::Multiname>(r.data).qname().ns);
+                case Type::Group:
+                    return std::get<GroupData>(l.data).group == std::get<GroupData>(r.data).group;
+            }
+            throw StringException("Unreachable area in similar");
+        }
+
+        template <bool truncate>
+        static std::vector<ContextItem> combine(ContextItem& c1, ContextItem& c2)
+        {
+            if (similar(c1, c2))
+                return {c1};
+
+            if (c1.type != Type::Multiname || c2.type != Type::Multiname)
+                return {};
+            if (std::get<ASASM::Multiname>(c1.data).kind != ABCType::QName ||
+                std::get<ASASM::Multiname>(c2.data).kind != ABCType::QName)
+                return {};
+
+            auto& name1 = std::get<ASASM::Multiname>(c1.data).qname().name;
+            auto& name2 = std::get<ASASM::Multiname>(c1.data).qname().name;
+            auto& ns1   = std::get<ASASM::Multiname>(c1.data).qname().ns;
+            auto& ns2   = std::get<ASASM::Multiname>(c1.data).qname().ns;
+
+            if constexpr (truncate)
+            {
+                if (nsSimilar(ns1, ns2) && !ns1.name.empty())
+                {
+                    ASASM::Multiname m;
+                    m.kind = ABCType::QName;
+                    m.qname(ASASM::Multiname::_QName{ns1});
+                    return {ContextItem{m}};
+                }
+
+                if (!name1.empty() && name2.empty())
+                {
+                    std::swap(c1, c2);
+                    std::swap(ns1, ns2);
+                    std::swap(name1, name2);
+                }
+            }
+
+            if (!name1.empty() && name2.empty() && nsSimilar(ns1, ns2))
+            {
+                if constexpr (truncate)
+                {
+                    ASASM::Multiname m;
+                    m.kind = ABCType::QName;
+                    m.qname(ASASM::Multiname::_QName{ns1});
+                    return {ContextItem(m)};
+                }
+                else
+                {
+                    return {c2};
+                }
+            }
+
+            if (!ns1.name.empty() && !ns2.name.empty())
+            {
+                if (nsSimilar(ns1, ns2))
+                {
+                    assert(name1 != name2);
+                    if constexpr (truncate)
+                    {
+                        assert(false);
+                    }
+                    else
+                    {
+                        if (!name2.empty())
+                        {
+                            return {c1, ContextItem(name2)};
+                        }
+                        else
+                        {
+                            return {c1};
+                        }
+                    }
+                }
+
+                if constexpr (truncate)
+                {
+                    if (ns1.name.size() > ns2.name.size())
+                    {
+                        std::swap(c1, c2);
+                        std::swap(ns1, ns2);
+                        std::swap(name1, name2);
+                    }
+                }
+
+                std::string fullName1 = ns1.name + (!name1.empty() ? ":" + name1 : "");
+                std::string fullName2 = ns2.name + (!name2.empty() ? ":" + name2 : "");
+                if (fullName2.starts_with(fullName1 + ":"))
+                    return {truncate ? c1 : c2};
+            }
+
+            return {};
+        }
+
+        static std::vector<ContextItem> commonRoot(ContextItem& c1, ContextItem& c2)
+        {
+            return combine<true>(c1, c2);
+        }
+
+        static std::vector<ContextItem> deduplicate(ContextItem& c1, ContextItem& c2)
+        {
+            return combine<false>(c1, c2);
+        }
+
+        static std::vector<ContextItem> contextRoot(
+            std::vector<ContextItem>& c1, std::vector<ContextItem>& c2)
+        {
+            constexpr auto uninteresting = [](const std::vector<ContextItem>& c) {
+                for (const auto& cc : c)
+                {
+                    assert(cc.type != Type::Group);
+                }
+
+                if (c.size() != 1)
+                {
+                    return false;
+                }
+
+                if (c[0].type != Type::String)
+                {
+                    return false;
+                }
+
+                return (std::get<StrData>(c[0].data).str.starts_with("script_") &&
+                           std::get<StrData>(c[0].data).str.ends_with("_sinit")) ||
+                       (std::get<StrData>(c[0].data).str.starts_with("orphan_method_"));
+            };
+
+            if (uninteresting(c1))
+                return c2;
+            if (uninteresting(c2))
+                return c1;
+
+            std::vector<ContextItem> c;
+            while (c.size() < c1.size() && c.size() < c2.size())
+            {
+                auto root = commonRoot(c1[c.size()], c2[c.size()]);
+                assert(root.size() <= 1);
+                if (!root.empty())
+                {
+                    c.emplace_back(std::move(root[0]));
+                }
+                else
+                    break;
+            }
+            return c;
+        }
+    };
+
+    std::vector<ContextItem> context;
+
+    template <typename... Ts>
+    void pushContext(Ts... args)
+    {
+        context.emplace_back(args...);
+    }
+    void popContext() { context.pop_back(); }
+
+    enum class ContextPriority : uint8_t
+    {
+        declaration,
+        usage,
+        orphan,
+        max
+    };
+
+    template <typename t, bool ALLOW_DUPLICATES>
+    struct ContextSet
+    {
+        using T = std::remove_cvref_t<t>;
+        mutable std::unordered_map<T, std::vector<ContextItem>> contexts;
+        std::unordered_map<T, std::array<std::vector<std::vector<ContextItem>>, 3>> contextSets;
+#ifndef NDEBUG
+        mutable bool contextsSealed = false;
+        mutable bool coagulated     = false;
+#endif
+
+        std::unordered_map<T, std::string> names, filenames;
+
+        bool add(T obj, const std::vector<ContextItem>& context, ContextPriority priority)
+        {
+            assert(!coagulated);
+            assert(!contextsSealed);
+
+            if (!contextSets.contains(obj))
+            {
+                contextSets[obj][(uint8_t)priority].emplace_back(context);
+                return true;
+            }
+            else
+            {
+                auto& pet = contextSets.at(obj)[(uint8_t)priority];
+                if (pet.size() == 0 || pet[pet.size() - 1] != context)
+                {
+                    pet.emplace_back(context);
+                }
+                return false;
+            }
+        }
+
+        bool addIfNew(T obj, const std::vector<ContextItem>& context, ContextPriority priority)
+        {
+            if (isAdded(obj))
+                return false;
+            else
+                return add(obj, context, priority);
+        }
+
+        bool isAdded(T obj) { return contextSets.contains(obj); }
+
+        void coagulate(const RefBuilder& refs)
+        {
+            assert(!coagulated);
+
+            std::unordered_map<std::string, int> collisionCounter;
+            std::unordered_map<std::string, T> first;
+
+            for (const auto& obj : contextSets)
+            {
+                if (!contexts.contains(obj.first))
+                {
+                    getContext(refs, obj.first);
+                }
+            }
+
+            for (const auto& obj : contexts)
+            {
+                std::string bname     = refs.contextToString(obj.second, false);
+                std::string bfilename = refs.contextToString(obj.second, true);
+                int counter = collisionCounter.contains(bname) ? collisionCounter.at(bname) : 0;
+                if (counter == 1)
+                {
+                    names.at(first[bname]) += "#0";
+                    filenames.at(first[bname]) += "#0";
+                }
+
+                std::string suffix;
+                if (counter == 0)
+                {
+                    first[bname] = obj.first;
+                }
+                else
+                {
+                    suffix = "#" + std::to_string(counter);
+                }
+                names.insert({obj.first, bname + suffix});
+                filenames.insert({obj.first, bfilename + suffix});
+                collisionCounter.insert({bname, counter + 1});
+            }
+
+#ifndef NDEBUG
+            coagulated = true;
+#endif
+        }
+
+        std::vector<ContextItem> getContext(const RefBuilder& refs, T obj) const
+        {
+#ifndef NDEBUG
+            contextsSealed = true;
+#endif
+
+            if (contexts.contains(obj))
+            {
+                return contexts.at(obj);
+            }
+
+            std::vector<std::vector<ContextItem>> set;
+
+            for (const auto& prioritySet : contextSets.at(obj))
+            {
+                if (!prioritySet.empty())
+                    set = prioritySet;
+            }
+
+            if constexpr (ALLOW_DUPLICATES)
+            {
+                std::vector<ContextItem> context = ContextItem::expand(refs, set[0]);
+                for (size_t i = 1; i < set.size(); i++)
+                {
+                    auto expanded = ContextItem::expand(refs, set[i]);
+                    context       = ContextItem::contextRoot(context, expanded);
+                }
+                contexts[obj] = context;
+            }
+            else
+            {
+                if (set.size() > 1)
+                {
+                    contexts[obj] = {ContextItem("multireferenced")};
+                }
+                else
+                {
+                    contexts[obj] = ContextItem::expand(refs, set[0]);
+                }
+            }
+
+            return contexts.at(obj);
+        }
+
+        std::string getName(T obj)
+        {
+            assert(coagulated);
+
+            return names.at(obj);
+        }
+
+        static inline std::unordered_map<std::string, std::string> filenameMappings;
+
+        std::string getFilename(T obj, std::string_view suffix)
+        {
+            assert(coagulated);
+
+            assert(filenames.contains(obj));
+            std::string filename = filenames.at(obj);
+
+            std::vector<std::string> dirSegments = StringUtils::split(filename, "/");
+            for (size_t l = 0; l < dirSegments.size(); l++)
+            {
+            again:
+                std::string subpath = StringUtils::join(dirSegments.data(), l, "/");
+                std::string subpathl(subpath.size(), '\0');
+                std::transform(subpath.begin(), subpath.end(), subpathl.begin(), tolower);
+
+                if (filenameMappings.contains(subpathl) && filenameMappings[subpathl] != subpath)
+                {
+                    dirSegments[l] += "_";
+                    goto again;
+                }
+                filenameMappings[subpathl] = subpath;
+            }
+            filename = StringUtils::join(dirSegments, "/");
+
+            std::string ret = filename + ".";
+            ret += suffix;
+            ret += ".asasm";
+            return ret;
+        }
+    };
+
+    std::array<ContextSet<uint32_t, true>, ABCTypeMap.GetEntries().second> namespaces;
+    ContextSet<const void*, false> objects, scripts;
+
+    RefBuilder(const ASASM::ASProgram& as) : ASTraitsVisitor(as) {}
+
+    std::unordered_map<const void*, bool> orphans;
+
+    void addOrphan(const void* obj) { orphans[obj] = true; }
+
+    bool isOrphan(const void* obj) { return orphans.contains(obj); }
+
+    void run() override
+    {
+        for (size_t i = 0; i < as.orphanClasses.size(); i++)
+        {
+            addOrphan(as.orphanClasses[i].get());
+        }
+        for (size_t i = 0; i < as.orphanMethods.size(); i++)
+        {
+            addOrphan(as.orphanMethods[i].get());
+        }
+
+        ASTraitsVisitor::run();
+
+        for (size_t i = 0; i < as.scripts.size(); i++)
+        {
+            std::vector<ContextItem> classContexts;
+
+            for (const auto& trait : as.scripts[i].traits)
+            {
+                if (trait.name.kind == ABCType::QName &&
+                    trait.name.qname().ns.kind != ABCType::PrivateNamespace)
+                    classContexts.emplace_back(trait.name);
+            }
+
+            if (classContexts.empty())
+            {
+                for (const auto& trait : as.scripts[i].traits)
+                {
+                    classContexts.emplace_back(trait.name);
+                }
+            }
+
+            context = {{classContexts, "script_" + std::to_string(i)}};
+            scripts.add(&as.scripts[i], context, ContextPriority::declaration);
+            pushContext("init", true);
+            addMethod(as.scripts[i].sinit, ContextPriority::declaration);
+            context.clear();
+        }
+
+        for (size_t i = 0; i < as.orphanClasses.size(); i++)
+        {
+            if (!objects.isAdded(as.orphanClasses[i].get()))
+            {
+                pushContext("orphan_class_" + std::to_string(i));
+                addClass(as.orphanClasses[i], ContextPriority::orphan);
+                popContext();
+            }
+        }
+        for (size_t i = 0; i < as.orphanMethods.size(); i++)
+        {
+            if (!objects.isAdded(as.orphanMethods[i].get()))
+            {
+                pushContext("orphan_method_" + std::to_string(i));
+                addMethod(as.orphanMethods[i], ContextPriority::orphan);
+                popContext();
+            }
+        }
+
+        scripts.coagulate(*this);
+
+        for (const auto& script : as.scripts)
+        {
+            for (const auto& trait : script.traits)
+            {
+                if (trait.name.kind == ABCType::QName)
+                {
+                    namespaces[(uint8_t)trait.name.qname().ns.kind].addIfNew(
+                        trait.name.qname().ns.id, scripts.getContext(*this, (const void*)&script),
+                        ContextPriority::declaration);
+                }
+            }
+        }
+
+        for (size_t i = 0; i < possibleOrphanPrivateNamespaces.size(); i++)
+        {
+            if (!namespaces[(uint8_t)ABCType::PrivateNamespace].isAdded(i))
+            {
+                pushContext("orphan_namespace_" + std::to_string(i));
+                namespaces[(uint8_t)ABCType::PrivateNamespace].add(
+                    i, context, ContextPriority::orphan);
+                popContext();
+            }
+        }
+
+#ifndef NDEBUG
+        homonymsBuilt = true;
+#endif
+
+        for (auto& ns : namespaces)
+        {
+            ns.coagulate(*this);
+        }
+        objects.coagulate(*this);
+    }
+
+    void visitTrait(const ASASM::Trait& trait) override
+    {
+        pushContext(trait.name);
+        visitMultiname(trait.name, ContextPriority::declaration);
+        switch (trait.kind)
+        {
+            case TraitKind::Slot:
+            case TraitKind::Const:
+                visitMultiname(trait.vSlot().typeName, ContextPriority::usage);
+
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+            case TraitKind::Class:
+                addClass(trait.vClass().vclass, ContextPriority::declaration);
+
+                pushContext("class", true);
+                visitTraits(trait.vClass().vclass->traits);
+                popContext();
+
+                pushContext("instance", true);
+                visitTraits(trait.vClass().vclass->instance.traits);
+                popContext();
+                break;
+            case TraitKind::Function:
+                addMethod(trait.vFunction().vfunction, ContextPriority::declaration);
+
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+            case TraitKind::Method:
+                addMethod(trait.vMethod().vmethod, ContextPriority::declaration);
+
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+            case TraitKind::Getter:
+                pushContext("getter");
+                addMethod(trait.vMethod().vmethod, ContextPriority::declaration);
+                popContext();
+
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+            case TraitKind::Setter:
+                pushContext("setter");
+                addMethod(trait.vMethod().vmethod, ContextPriority::declaration);
+                popContext();
+
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+            default:
+                ASTraitsVisitor::visitTrait(trait);
+                break;
+        }
+        popContext();
+    }
+
+    std::unordered_map<uint32_t, bool> possibleOrphanPrivateNamespaces;
+
+    void visitNamespace(const ASASM::Namespace& ns, ContextPriority priority)
+    {
+        if (ns.kind == ABCType::Void)
+            return;
+
+        addHomonym(ns);
+
+        assert(context.size() > 0);
+
+        size_t myPos = context.size();
+        for (size_t i = 0; i < context.size(); i++)
+        {
+            if (context[i].type == ContextItem::Type::Multiname &&
+                std::get<ASASM::Multiname>(context[i].data).kind == ABCType::QName &&
+                std::get<ASASM::Multiname>(context[i].data).qname().ns == ns)
+            {
+                myPos = i;
+                break;
+            }
+        }
+        if (ns.kind == ABCType::PrivateNamespace && myPos == 0)
+        {
+            possibleOrphanPrivateNamespaces[ns.id] = true;
+            return;
+        }
+
+        std::vector<ContextItem> myContext{context.begin(), context.begin() + myPos};
+        namespaces[(uint8_t)ns.kind].add(ns.id, myContext, priority);
+    }
+
+    void visitNamespaceSet(const std::vector<ASASM::Namespace>& nsSet, ContextPriority priority)
+    {
+        for (const auto& ns : nsSet)
+        {
+            visitNamespace(ns, priority);
+        }
+    }
+
+    void visitMultiname(const ASASM::Multiname& m, ContextPriority priority)
+    {
+        if (m.kind == ABCType::Void)
+            return;
+        switch (m.kind)
+        {
+            case ABCType::QName:
+            case ABCType::QNameA:
+                visitNamespace(m.qname().ns, priority);
+                break;
+            case ABCType::Multiname:
+            case ABCType::MultinameA:
+                visitNamespaceSet(m.multiname().nsSet, priority);
+                break;
+            case ABCType::MultinameL:
+            case ABCType::MultinameLA:
+                visitNamespaceSet(m.multinamel().nsSet, priority);
+                break;
+            case ABCType::TypeName:
+                visitMultiname(m.Typename().name(), priority);
+                for (const auto& param : m.Typename().params())
+                    visitMultiname(param, priority);
+                break;
+            default:
+                break;
+        }
+    }
+
+    void visitMethodBody(const ASASM::MethodBody& b)
+    {
+        for (const auto& instruction : b.instructions)
+        {
+            for (size_t i = 0; i < OPCode_Info[(uint8_t)instruction.opcode].second.size(); i++)
+            {
+                switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+                {
+                    case OPCodeArgumentType::Namespace:
+                        visitNamespace(
+                            instruction.arguments[i].namespacev(), ContextPriority::usage);
+                        break;
+                    case OPCodeArgumentType::Multiname:
+                        visitMultiname(
+                            instruction.arguments[i].multinamev(), ContextPriority::usage);
+                        break;
+                    case OPCodeArgumentType::Class:
+                        pushContext("inline_class");
+                        if (isOrphan(instruction.arguments[i].classv().get()))
+                            addClass(instruction.arguments[i].classv(), ContextPriority::usage);
+                        popContext();
+                        break;
+                    case OPCodeArgumentType::Method:
+                        pushContext("inline_method");
+                        if (isOrphan(instruction.arguments[i].methodv().get()))
+                            addMethod(instruction.arguments[i].methodv(), ContextPriority::usage);
+                        popContext();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+
+    std::string contextToString(std::vector<ContextItem> context, bool filename) const
+    {
+        context = ContextItem::expand(*this, context);
+        if (context.empty())
+            return "";
+
+        for (size_t i = context.size() - 1; i > 0; i--)
+        {
+            auto root = ContextItem::deduplicate(context[i - 1], context[i]);
+            if (!root.empty())
+            {
+                std::vector<ContextItem> newContext{context.begin(), context.begin() + i - 1};
+                newContext.insert(newContext.end(), root.begin(), root.end());
+                newContext.insert(newContext.end(), context.begin() + i + 1, context.end());
+                context = std::move(newContext);
+            }
+        }
+
+        std::vector<ContextItem::Segment> segments;
+        for (const auto& ci : context)
+        {
+            auto newSegments = ci.toSegments(*this, filename);
+            segments.insert(segments.end(), newSegments.begin(), newSegments.end());
+        }
+
+        auto escape = [&](std::string_view s) {
+            if (!filename)
+                return std::string(s);
+
+            std::string ret;
+            for (char c : s)
+            {
+                if (c == '.' || c == ':')
+                {
+                    ret += '/';
+                }
+                else if (c == '\\' || c == '*' || c == '?' || c == '"' || c == '<' || c == '>' ||
+                         c == '|' || c < 0x20 || c >= 0x7F || c == ' ' || c == '%')
+                {
+                    char output[5] = {'\0'};
+                    sprintf(output, "%%%02X", c);
+                    ret += output;
+                }
+                else
+                {
+                    ret += c;
+                }
+            }
+
+            auto pathSegments = StringUtils::split(ret, "/");
+            if (pathSegments.empty())
+            {
+                pathSegments = {""};
+            }
+            for (auto& segment : pathSegments)
+            {
+                if (segment == "")
+                {
+                    segment = "%";
+                }
+
+                static constexpr std::array<std::string_view, 22> reservedNames = {"CON", "PRN",
+                    "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8",
+                    "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"};
+
+                std::string segmentU(segment.size(), '\0');
+                std::transform(segment.begin(), segment.end(), segmentU.begin(), toupper);
+                for (const auto& reservedName : reservedNames)
+                {
+                    if (segmentU.starts_with(reservedName) &&
+                        (segmentU.size() == reservedName.size() ||
+                            segmentU[reservedName.size()] == '.'))
+                    {
+                        segment = "%" + segment;
+                    }
+                }
+
+                // TODO: see whether this is really necessary, and, if so, add it
+                // if (segment.size() > 240)
+                // {
+                //     segment = segment.substr(0, 200) + '-' + toHexString(md5Of(segment));
+                // }
+            }
+
+            return StringUtils::join(pathSegments, "/");
+        };
+
+        std::vector<std::string> strings(segments.size());
+        for (size_t i = 0; i < segments.size(); i++)
+        {
+            if (i > 0)
+            {
+                strings[i] = segments[i].delim + escape(segments[i].str);
+            }
+            else
+            {
+                strings[i] = escape(segments[i].str);
+            }
+        }
+
+        return StringUtils::join(strings, "");
+    }
+
+    template <typename T>
+    bool addObject(T obj, ContextPriority priority)
+    {
+        return objects.add(obj.get(), context, priority);
+    }
+
+    void addClass(const std::shared_ptr<ASASM::Class> vclass, ContextPriority priority)
+    {
+        addObject(vclass, priority);
+
+        pushContext("class", true);
+        pushContext("init", true);
+        addMethod(vclass->cinit, ContextPriority::declaration);
+        popContext();
+        popContext();
+
+        pushContext("instance", true);
+        pushContext("init", true);
+        addMethod(vclass->instance.iinit, ContextPriority::declaration);
+        popContext();
+
+        visitMultiname(vclass->instance.name, ContextPriority::declaration);
+        visitMultiname(vclass->instance.superName, ContextPriority::usage);
+        visitNamespace(vclass->instance.protectedNs, ContextPriority::declaration);
+        for (const auto& iface : vclass->instance.interfaces)
+        {
+            visitMultiname(iface, ContextPriority::usage);
+        }
+        popContext();
+    }
+
+    void addMethod(const std::shared_ptr<ASASM::Method> method, ContextPriority priority)
+    {
+        if (addObject(method, priority))
+        {
+            for (const auto& paramType : method->paramTypes)
+            {
+                visitMultiname(paramType, ContextPriority::usage);
+            }
+            visitMultiname(method->returnType, ContextPriority::usage);
+            if (method->vbody)
+            {
+                visitMethodBody(*method->vbody);
+            }
+        }
+    }
+};
diff --git a/Native/BytecodeEditor/include/utils/SmallTrivialVector.hpp b/Native/BytecodeEditor/include/utils/SmallTrivialVector.hpp
new file mode 100644
index 0000000..ecca7ef
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/SmallTrivialVector.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <array>
+#include <initializer_list>
+#include <type_traits>
+
+template <typename T, size_t Size>
+requires std::is_trivial_v<T> class SmallTrivialVector
+{
+private:
+    std::array<T, Size> data{};
+    size_t populated{0};
+
+public:
+    consteval SmallTrivialVector() = default;
+
+    consteval SmallTrivialVector(std::initializer_list<T> in) : data(), populated(in.size())
+    {
+        for (size_t i = 0; i < in.size(); i++)
+        {
+            data[i] = *(in.begin() + i);
+        }
+    }
+
+    consteval SmallTrivialVector(std::array<T, Size> in) : data(), populated(Size)
+    {
+        for (size_t i = 0; i < Size; i++)
+        {
+            data[i] = in[i];
+        }
+    }
+
+    template <size_t ArraySize>
+    consteval SmallTrivialVector(std::array<T, ArraySize> in) : data(), populated(ArraySize)
+    {
+        for (size_t i = 0; i < ArraySize; i++)
+        {
+            data[i] = in[i];
+        }
+    }
+
+    constexpr const T& operator[](size_t i) const { return data[i]; }
+    constexpr T& operator[](size_t i) { return data[i]; }
+
+    constexpr size_t size() const { return populated; }
+};
diff --git a/Native/BytecodeEditor/include/utils/StringBuilder.hpp b/Native/BytecodeEditor/include/utils/StringBuilder.hpp
new file mode 100644
index 0000000..e4d5845
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/StringBuilder.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <sstream>
+
+class StringBuilder : public std::stringstream
+{
+public:
+    bool indented;
+    int indent;
+    std::string linePrefix;
+
+    template <typename T>
+    void write(T v)
+    {
+        checkIndent();
+        *this << std::forward<T>(v);
+    }
+
+    void newLine()
+    {
+        *this << '\n';
+        indented = false;
+    }
+
+    void noIndent() { indented = true; }
+
+    void checkIndent()
+    {
+        if (!indented)
+        {
+            // for (int i = 0; i < indent; i++)
+            //  *this << ' ';
+            indented = true;
+            if (!linePrefix.empty())
+                *this << linePrefix;
+        }
+    }
+};
diff --git a/Native/BytecodeEditor/include/utils/StringException.hpp b/Native/BytecodeEditor/include/utils/StringException.hpp
new file mode 100644
index 0000000..4e05b68
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/StringException.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <exception>
+#include <string>
+
+class StringException : public std::exception
+{
+public:
+    StringException(std::string data) : data(data) {}
+
+    const char* what() const noexcept override { return data.c_str(); }
+
+private:
+    std::string data;
+};
diff --git a/Native/BytecodeEditor/include/utils/StringUtils.hpp b/Native/BytecodeEditor/include/utils/StringUtils.hpp
new file mode 100644
index 0000000..23499aa
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/StringUtils.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace StringUtils
+{
+    std::vector<std::string> split(std::string_view s, std::string_view delimiter)
+    {
+        std::vector<std::string> ret;
+        if (delimiter.size() == 0)
+        {
+            ret.reserve(s.size());
+            for (size_t i = 0; i < s.size(); i++)
+            {
+                ret.emplace_back(s.substr(i, 1));
+            }
+            return ret;
+        }
+        size_t found = s.find(delimiter);
+        while (found != std::string::npos)
+        {
+            ret.emplace_back(s.substr(0, found));
+            s     = s.substr(found + delimiter.size());
+            found = s.find(delimiter);
+        }
+        ret.emplace_back(s);
+
+        return ret;
+    }
+
+    std::string join(const std::string_view* s, size_t len, std::string_view joiner)
+    {
+        if (len == 0)
+        {
+            return "";
+        }
+
+        size_t sizeNeeded = s[0].size();
+        for (size_t i = 1; i < len; i++)
+        {
+            sizeNeeded += s[i].size() + joiner.size();
+        }
+
+        std::string ret;
+        ret.reserve(sizeNeeded);
+
+        ret += s[0];
+        for (size_t i = 1; i < len; i++)
+        {
+            ret += joiner;
+            ret += s[i];
+        }
+        return ret;
+    }
+    std::string join(const std::string* s, size_t len, std::string_view joiner)
+    {
+        if (len == 0)
+        {
+            return "";
+        }
+
+        size_t sizeNeeded = s[0].size();
+        for (size_t i = 1; i < len; i++)
+        {
+            sizeNeeded += s[i].size() + joiner.size();
+        }
+
+        std::string ret;
+        ret.reserve(sizeNeeded);
+
+        ret += s[0];
+        for (size_t i = 1; i < len; i++)
+        {
+            ret += joiner;
+            ret += s[i];
+        }
+        return ret;
+    }
+    std::string join(const std::vector<std::string_view>& s, std::string_view joiner)
+    {
+        return join(s.data(), s.size(), joiner);
+    }
+    std::string join(const std::vector<std::string>& s, std::string_view joiner)
+    {
+        return join(s.data(), s.size(), joiner);
+    }
+}
diff --git a/Native/BytecodeEditor/include/utils/ValuePool.hpp b/Native/BytecodeEditor/include/utils/ValuePool.hpp
new file mode 100644
index 0000000..efe2e68
--- /dev/null
+++ b/Native/BytecodeEditor/include/utils/ValuePool.hpp
@@ -0,0 +1,259 @@
+#pragma once
+
+#include "ASASM/Multiname.hpp"
+#include "ASASM/Namespace.hpp"
+#include <algorithm>
+#include <bit>
+#include <cassert>
+#include <map>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <type_traits>
+
+template <typename T, bool haveNull>
+class ValuePoolBase
+{
+public:
+    using Key = std::remove_cvref_t<T>;
+    static Key toKey(T val) { return val; }
+};
+
+template <bool haveNull>
+class ValuePoolBase<double, haveNull>
+{
+    static_assert(sizeof(double) == sizeof(uint64_t));
+
+public:
+    using Key = uint64_t;
+    static Key toKey(double val) { return std::bit_cast<uint64_t>(val); }
+};
+
+template <typename T, bool haveNull>
+class ValuePoolBase<std::shared_ptr<T>, haveNull>
+{
+public:
+    using Key = T*;
+    static Key toKey(const std::shared_ptr<T>& val) { return val.get(); }
+};
+
+template <typename T, bool haveNull = true>
+class ValuePool : private ValuePoolBase<T, haveNull>
+{
+private:
+    using Key = ValuePoolBase<T, haveNull>::Key;
+    using ValuePoolBase<T, haveNull>::toKey;
+
+    template <typename T>
+    constexpr bool isNull(T v)
+    {
+        using comp = std::remove_cvref_t<decltype(v)>;
+        static_assert(std::is_same_v<comp, uint64_t> || std::is_same_v<comp, int64_t> ||
+                      std::is_same_v<comp, double> || std::is_same_v<comp, std::string> ||
+                      std::is_same_v<comp, ASASM::Multiname> ||
+                      std::is_same_v<comp, std::vector<ASASM::Namespace>> ||
+                      std::is_same_v<comp, ASASM::Namespace> ||
+                      std::is_same_v<comp, ASASM::Metadata> ||
+                      std::is_same_v<comp, std::shared_ptr<ASASM::Class>> ||
+                      std::is_same_v<comp, std::shared_ptr<ASASM::Method>>);
+        if constexpr (std::is_same_v<comp, uint64_t>)
+        {
+            return v == ABC::ABCFile::NULL_UINT;
+        }
+        else if constexpr (std::is_same_v<comp, int64_t>)
+        {
+            return v == ABC::ABCFile::NULL_INT;
+        }
+        else if constexpr (std::is_same_v<comp, double>)
+        {
+            return std::isnan(v);
+        }
+        else if constexpr (std::is_same_v<comp, std::string>)
+        {
+            return false;
+        }
+        else if constexpr (std::is_same_v<comp, ASASM::Multiname>)
+        {
+            return v.kind == ABCType::Void;
+        }
+        else if constexpr (std::is_same_v<comp, std::vector<ASASM::Namespace>>)
+        {
+            return v.empty();
+        }
+        else if constexpr (std::is_same_v<comp, ASASM::Namespace>)
+        {
+            return v.kind == ABCType::Void;
+        }
+        else if constexpr (std::is_same_v<comp, ASASM::Metadata>)
+        {
+            return false;
+        }
+        else if constexpr (std::is_same_v<comp, std::shared_ptr<ASASM::Class>> ||
+                           std::is_same_v<comp, std::shared_ptr<ASASM::Method>>)
+        {
+            return v == nullptr;
+        }
+    }
+
+public:
+    struct Entry
+    {
+        uint32_t hits;
+        T value;
+        size_t addIndex, index;
+        std::vector<Key> parents;
+    };
+
+    std::map<Key, Entry> pool;
+    std::vector<T> values;
+
+    bool add(const T& value)
+    {
+        if constexpr (haveNull || std::is_pointer_v<Key>)
+        {
+            if (isNull(value))
+            {
+                return false;
+            }
+        }
+
+        auto key = toKey(value);
+        if (pool.contains(key))
+        {
+            pool[key].hits++;
+            return false;
+        }
+        else
+        {
+            pool.emplace(key, Entry{1, value, pool.size(), 0, {}});
+            return true;
+        }
+    }
+
+    bool notAdded(const T& value)
+    {
+        if constexpr (haveNull || std::is_pointer_v<Key>)
+        {
+            if (isNull(value))
+            {
+                return false;
+            }
+        }
+
+        auto key = toKey(value);
+        if (pool.contains(key))
+        {
+            pool[key].hits++;
+            return false;
+        }
+        return true;
+    }
+
+    void registerDependency(const T& _from, const T& _to)
+    {
+        auto from = toKey(_from);
+        auto to   = toKey(_to);
+
+        assert(pool.contains(from));
+        assert(pool.contains(to));
+
+        auto& fromV = pool[from];
+
+        assert(std::none_of(
+            fromV.parents.begin(), fromV.parents.end(), [to](const Key& k) { return k == to; }));
+
+        fromV.parents.emplace_back(to);
+    }
+
+    std::vector<T> getPreliminaryValues() const
+    {
+        std::vector<T> ret;
+        ret.reserve(pool.size());
+
+        for (const auto& pair : pool)
+        {
+            ret.emplace_back(pair.second.value);
+        }
+
+        return ret;
+    }
+
+    std::vector<T>& finalize()
+    {
+        std::vector<Entry*> all;
+        all.reserve(pool.size());
+
+        for (auto& pair : pool)
+        {
+            all.emplace_back(&pair.second);
+        }
+
+        if constexpr (std::is_same_v<T, double>)
+        {
+            constexpr auto sortPred = [](Entry* a, Entry* b) {
+                return a->hits > b->hits ||
+                       (a->hits == b->hits &&
+                           std::bit_cast<uint64_t>(a->value) < std::bit_cast<uint64_t>(b->value));
+            };
+            std::sort(all.begin(), all.end(), sortPred);
+        }
+        else if constexpr (std::is_pointer_v<Key>)
+        {
+            constexpr auto sortPred = [](Entry* a, Entry* b) {
+                return a->hits > b->hits || (a->hits == b->hits && a->addIndex < b->addIndex);
+            };
+            std::sort(all.begin(), all.end(), sortPred);
+        }
+        else
+        {
+            constexpr auto sortPred = [](Entry* a, Entry* b) {
+                return a->hits > b->hits || (a->hits == b->hits && a->value < b->value);
+            };
+            std::sort(all.begin(), all.end(), sortPred);
+        }
+
+    // topographical sort
+    topSort:
+
+        for (size_t i = 0; i < all.size(); i++)
+        {
+            all[i]->index = i;
+        }
+
+        for (const auto& a : pool)
+        {
+            for (const auto& parent : a.second.parents)
+            {
+                assert(pool.contains(parent));
+                if (pool[parent].index > a.second.index)
+                {
+                    all.erase(all.begin() + pool[parent].index);
+                    all.insert(all.begin() + a.second.index, &pool[parent]);
+                    goto topSort;
+                }
+            }
+        }
+
+        values.reserve(all.size() + (haveNull ? 1 : 0));
+        if constexpr (haveNull)
+        {
+            values.emplace_back();
+        }
+
+        for (const Entry* e : all)
+        {
+            values.emplace_back(e->value);
+        }
+
+        return values;
+    }
+
+    uint32_t get(T value)
+    {
+        if (haveNull && isNull(value))
+        {
+            return 0;
+        }
+        return pool[toKey(value)].index + (haveNull ? 1 : 0);
+    }
+};
diff --git a/Native/BytecodeEditor/source/ANEBytecodeEditor.cpp b/Native/BytecodeEditor/source/ANEBytecodeEditor.cpp
new file mode 100644
index 0000000..478e01b
--- /dev/null
+++ b/Native/BytecodeEditor/source/ANEBytecodeEditor.cpp
@@ -0,0 +1,233 @@
+#include "ANEBytecodeEditor.hpp"
+#include "BytecodeEditor.hpp"
+#include "utils/ANEUtils.hpp"
+
+#include <string_view>
+#include <vector>
+
+static FREContext AIRContext;
+
+#define GET_EDITOR(ctx)                                                                            \
+    BytecodeEditor* editor = nullptr;                                                              \
+    do                                                                                             \
+    {                                                                                              \
+        void* o;                                                                                   \
+        DO_OR_FAIL("Failed to get reference to BytecodeEditor instance",                           \
+            FREGetContextNativeData(ctx, &o));                                                     \
+        editor = static_cast<BytecodeEditor*>(o);                                                  \
+    } while (false)
+
+FREObject Disassemble(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 0)
+    {
+        FAIL("argc should be 0");
+    }
+
+    GET_EDITOR(ctx);
+
+    return editor->disassemble();
+}
+
+FREObject Assemble(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 2)
+    {
+        FAIL("argc should be 2");
+    }
+
+    GET_EDITOR(ctx);
+
+    FREObjectType type;
+    DO_OR_FAIL("Failed to get argv[0] type", FREGetObjectType(argv[0], &type));
+    if (type != FRE_TYPE_OBJECT)
+    {
+        FAIL("argv[0] is not an object");
+    }
+    DO_OR_FAIL("Failed to get argv[1] type", FREGetObjectType(argv[1], &type));
+    if (type != FRE_TYPE_VECTOR)
+    {
+        FAIL("argv[1] is not a vector");
+    }
+
+    uint32_t vecSize;
+    DO_OR_FAIL("Failed to get argv[1] size", FREGetArrayLength(argv[1], &vecSize));
+
+    std::unordered_map<std::string, std::string> strings;
+    for (uint32_t i = 0; i < vecSize; i++)
+    {
+        FREObject str;
+        DO_OR_FAIL("Failed to get argv[1][i]", FREGetArrayElementAt(argv[1], i, &str));
+        char* key;
+        uint32_t keyLen;
+        DO_OR_FAIL("Failed to get argv[1][i]'s string value",
+            FREGetObjectAsUTF8(str, &keyLen, (const uint8_t**)&key));
+        FREObject str2;
+        DO_OR_FAIL("Failed to get argv[0][argv[1][i]]",
+            FREGetObjectProperty(argv[0], (const uint8_t*)key, &str2, nullptr));
+        char* val;
+        uint32_t valLen;
+        DO_OR_FAIL("Failed to get argv[0][argv[1][i]]'s string value",
+            FREGetObjectAsUTF8(str2, &valLen, (const uint8_t**)&val));
+        strings.emplace(key, val);
+    }
+
+    return editor->assemble(std::move(strings));
+}
+
+FREObject DisassembleAsync(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 0)
+    {
+        FAIL("argc should be 0");
+    }
+
+    GET_EDITOR(ctx);
+
+    return editor->disassembleAsync();
+}
+
+FREObject AssembleAsync(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 2)
+    {
+        FAIL("argc should be 2");
+    }
+
+    GET_EDITOR(ctx);
+
+    FREObjectType type;
+    DO_OR_FAIL("Failed to get argv[0] type", FREGetObjectType(argv[0], &type));
+    if (type != FRE_TYPE_OBJECT)
+    {
+        FAIL("argv[0] is not an object");
+    }
+    DO_OR_FAIL("Failed to get argv[1] type", FREGetObjectType(argv[1], &type));
+    if (type != FRE_TYPE_VECTOR)
+    {
+        FAIL("argv[1] is not a vector");
+    }
+
+    uint32_t vecSize;
+    DO_OR_FAIL("Failed to get argv[1] size", FREGetArrayLength(argv[1], &vecSize));
+
+    std::unordered_map<std::string, std::string> strings;
+    for (uint32_t i = 0; i < vecSize; i++)
+    {
+        FREObject str;
+        DO_OR_FAIL("Failed to get argv[1][i]", FREGetArrayElementAt(argv[1], i, &str));
+        char* key;
+        uint32_t keyLen;
+        DO_OR_FAIL("Failed to get argv[1][i]'s string value",
+            FREGetObjectAsUTF8(str, &keyLen, (const uint8_t**)&key));
+        FREObject str2;
+        DO_OR_FAIL("Failed to get argv[0][argv[1][i]]",
+            FREGetObjectProperty(argv[0], (const uint8_t*)key, &str2, nullptr));
+        char* val;
+        uint32_t valLen;
+        DO_OR_FAIL("Failed to get argv[0][argv[1][i]]'s string value",
+            FREGetObjectAsUTF8(str2, &valLen, (const uint8_t**)&val));
+        strings.emplace(key, val);
+    }
+
+    return editor->assembleAsync(std::move(strings));
+}
+
+FREObject AsyncTaskResult(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 0)
+    {
+        FAIL("argc should be 0");
+    }
+
+    GET_EDITOR(ctx);
+
+    return editor->taskResult();
+}
+
+FREObject SetCurrentSWF(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 1)
+    {
+        FAIL("argc should be 1");
+    }
+
+    GET_EDITOR(ctx);
+
+    FREObjectType type;
+    DO_OR_FAIL("Failed to get object type", FREGetObjectType(argv[0], &type));
+    if (type != FRE_TYPE_BYTEARRAY)
+    {
+        FAIL("argv[0] is not a bytearray");
+    }
+
+    FREByteArray ba;
+    DO_OR_FAIL("Failed to acquire bytearray", FREAcquireByteArray(argv[0], &ba));
+
+    std::vector<uint8_t> data;
+    data.insert(data.begin(), ba.bytes, ba.bytes + ba.length);
+    DO_OR_FAIL("Failed to release bytearray", FREReleaseByteArray(argv[0]));
+
+    try
+    {
+        editor->setSWF(SWF::SWFFile(std::move(data)));
+    }
+    catch (std::exception& e)
+    {
+        FAIL(e.what());
+    }
+
+    FREObject ret;
+    DO_OR_FAIL("Failed to create success boolean", FRENewObjectFromBool(1, &ret));
+    return ret;
+}
+
+FREObject Cleanup(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[])
+{
+    if (argc != 0)
+    {
+        FAIL("argc should be 0");
+    }
+
+    GET_EDITOR(ctx);
+
+    editor->cleanup();
+
+    return nullptr;
+}
+
+static FRENamedFunction ANEBE_functions[] = {
+    {(const uint8_t*)"Disassemble", nullptr, &Disassemble},
+    {(const uint8_t*)"Assemble", nullptr, &Assemble},
+    {(const uint8_t*)"DisassembleAsync", nullptr, &DisassembleAsync},
+    {(const uint8_t*)"AssembleAsync", nullptr, &AssembleAsync},
+    {(const uint8_t*)"AsyncTaskResult", nullptr, &AsyncTaskResult},
+    {(const uint8_t*)"SetCurrentSWF", nullptr, &SetCurrentSWF},
+    {(const uint8_t*)"Cleanup", nullptr, &Cleanup},
+};
+
+void ContextInitializer(void* extData, const uint8_t* ctxType, FREContext ctx,
+    uint32_t* numFunctions, const FRENamedFunction** functions)
+{
+    *functions    = ANEBE_functions;
+    *numFunctions = sizeof(ANEBE_functions) / sizeof(ANEBE_functions[0]);
+
+    FRESetContextNativeData(ctx, new BytecodeEditor(ctx));
+}
+
+void ContextFinalizer(FREContext ctx)
+{
+    void* d;
+    FREGetContextNativeData(ctx, &d);
+    delete static_cast<BytecodeEditor*>(d);
+}
+
+extern "C" EXPORT void ExtInitializerANEBytecodeEditor(void** extDataToSet,
+    FREContextInitializer* ctxInitializerToSet, FREContextFinalizer* ctxFinalizerToSet)
+{
+    *extDataToSet        = nullptr;
+    *ctxInitializerToSet = &ContextInitializer;
+    *ctxFinalizerToSet   = &ContextFinalizer;
+}
+
+extern "C" EXPORT void ExtFinalizerANEBytecodeEditor(void* extDat) {}
diff --git a/Native/BytecodeEditor/source/ASASM/ASProgram.cpp b/Native/BytecodeEditor/source/ASASM/ASProgram.cpp
new file mode 100644
index 0000000..d57584d
--- /dev/null
+++ b/Native/BytecodeEditor/source/ASASM/ASProgram.cpp
@@ -0,0 +1,422 @@
+#include "ASASM/ASProgram.hpp"
+#include "ASASM/AStoABC.hpp"
+
+ASASM::ASProgram ASASM::ASProgram::fromABC(const ABC::ABCFile& abc)
+{
+    ASProgram asp;
+
+    std::vector<Namespace> namespaces;
+    std::vector<std::vector<Namespace>> namespaceSets;
+    std::vector<Multiname> multinames;
+    std::vector<Metadata> metadatas;
+    std::vector<Instance> instances;
+
+    std::vector<std::shared_ptr<Class>> classes;
+    std::vector<std::shared_ptr<Method>> methods;
+
+    std::vector<bool> methodAdded;
+    std::vector<bool> classAdded;
+
+    // Whether or not the class has already been converted
+    std::vector<bool> classSet;
+
+    const auto getMethod = [&](uint32_t index) -> std::shared_ptr<Method>& {
+        methodAdded[index] = true;
+        return methods[index];
+    };
+    const auto getClass = [&](uint32_t index) -> std::shared_ptr<Class>& {
+        classAdded[index] = true;
+        return classes[index];
+    };
+
+    const auto convertValue = [&](ABCType kind, uint32_t val) {
+        Value ret;
+        ret.vkind = kind;
+        switch (kind)
+        {
+            case ABCType::Integer:
+                ret.vint(abc.ints[val]); // WARNING: discarding extra bits
+                break;
+            case ABCType::UInteger:
+                ret.vuint(abc.uints[val]); // WARNING: discarding extra bits
+                break;
+            case ABCType::Double:
+                ret.vdouble(abc.doubles[val]);
+                break;
+            case ABCType::Utf8:
+                ret.vstring(abc.strings[val]);
+                break;
+            case ABCType::Namespace:
+            case ABCType::PackageNamespace:
+            case ABCType::PackageInternalNs:
+            case ABCType::ProtectedNamespace:
+            case ABCType::ExplicitNamespace:
+            case ABCType::StaticProtectedNs:
+            case ABCType::PrivateNamespace:
+                ret.vnamespace(namespaces[val]);
+                break;
+            case ABCType::True:
+            case ABCType::False:
+            case ABCType::Null:
+            case ABCType::Undefined:
+                break;
+            default:
+                throw StringException("Unknown type");
+        }
+        return ret;
+    };
+
+    const auto convertNamespace = [&](const ABC::Namespace& ns, int id) {
+        return Namespace{ns.kind, abc.strings[ns.name], id};
+    };
+
+    const auto convertNamespaceSet = [&](const std::vector<int32_t>& nsSet) {
+        std::vector<Namespace> ret(nsSet.size());
+        for (size_t i = 0; i < nsSet.size(); i++)
+        {
+            ret[i] = namespaces[nsSet[i]];
+        }
+        return ret;
+    };
+
+    const auto convertMultiname = [&](const ABC::Multiname& multiname) {
+        Multiname ret;
+        ret.kind = multiname.kind;
+        switch (multiname.kind)
+        {
+            case ABCType::QName:
+            case ABCType::QNameA:
+                ret.qname({namespaces[multiname.qname().ns], abc.strings[multiname.qname().name]});
+                break;
+            case ABCType::RTQName:
+            case ABCType::RTQNameA:
+                ret.rtqname({abc.strings[multiname.rtqname().name]});
+                break;
+            case ABCType::RTQNameL:
+            case ABCType::RTQNameLA:
+                ret.rtqnamel({});
+                break;
+            case ABCType::Multiname:
+            case ABCType::MultinameA:
+                ret.multiname({abc.strings[multiname.multiname().name],
+                    namespaceSets[multiname.multiname().nsSet]});
+                break;
+            case ABCType::MultinameL:
+            case ABCType::MultinameLA:
+                ret.multinamel({namespaceSets[multiname.multinamel().nsSet]});
+                break;
+            case ABCType::TypeName:
+                // handled in postConvertMultiname; needs the sub-multinames to be processed
+                // first
+                break;
+            default:
+                throw StringException("Unknown Multiname kind");
+        }
+        return ret;
+    };
+
+    const auto postConvertMultiname = [&](const ABC::Multiname& multiname, Multiname& edit) {
+        if (multiname.kind == ABCType::TypeName)
+        {
+            Multiname::_Typename nTypeName{multinames[multiname.Typename().name]};
+            nTypeName.params().reserve(multiname.Typename().params.size());
+            for (size_t i = 0; i < multiname.Typename().params.size(); i++)
+            {
+                nTypeName.params().emplace_back(multinames[multiname.Typename().params[i]]);
+            }
+
+            edit.Typename(nTypeName);
+        }
+    };
+
+    const auto convertMethod = [&](const ABC::MethodInfo& method, int id) {
+        std::shared_ptr<Method> ret = std::make_shared<Method>();
+        ret->paramTypes.reserve(method.paramTypes.size());
+        for (const auto& param : method.paramTypes)
+        {
+            ret->paramTypes.emplace_back(multinames[param]);
+        }
+        ret->returnType = multinames[method.returnType];
+        ret->name       = abc.strings[method.name];
+        ret->flags      = method.flags;
+        ret->options.reserve(method.options.size());
+        for (const auto& option : method.options)
+        {
+            ret->options.emplace_back(convertValue(option.kind, option.value));
+        }
+        ret->paramNames.reserve(method.paramNames.size());
+        for (const auto& name : method.paramNames)
+        {
+            ret->paramNames.emplace_back(abc.strings[name]);
+        }
+        ret->id = id;
+        return ret;
+    };
+
+    const auto convertMetadata = [&](const ABC::Metadata& metadata) {
+        Metadata ret;
+        ret.name = abc.strings[metadata.name];
+        ret.data.reserve(metadata.data.size());
+        for (const auto& kv : metadata.data)
+        {
+            ret.data.emplace_back(abc.strings[kv.first], abc.strings[kv.second]);
+        }
+        return ret;
+    };
+
+    const auto convertTraits = [&](const std::vector<ABC::TraitsInfo>& traits) {
+        std::vector<Trait> ret;
+        ret.reserve(traits.size());
+        for (const auto& trait : traits)
+        {
+            Trait add;
+            add.name       = multinames[trait.name];
+            add.kind       = trait.kind();
+            add.attributes = trait.attr();
+            switch (trait.kind())
+            {
+                case TraitKind::Slot:
+                case TraitKind::Const:
+                    add.vSlot({trait.Slot.slotId, multinames[trait.Slot.typeName],
+                        convertValue(trait.Slot.vkind, trait.Slot.vindex)});
+                    break;
+                case TraitKind::Class:
+                    if (classes.size() == 0 || !classSet[trait.Class.classi])
+                        throw StringException("Forward class reference");
+                    add.vClass({trait.Class.slotId, getClass(trait.Class.classi)});
+                    break;
+                case TraitKind::Function:
+                    add.vFunction({trait.Function.slotId, getMethod(trait.Function.functioni)});
+                    break;
+                case TraitKind::Method:
+                case TraitKind::Getter:
+                case TraitKind::Setter:
+                    add.vMethod({trait.Method.dispId, getMethod(trait.Method.method)});
+                    break;
+                default:
+                    throw StringException("Unknown trait kind");
+            }
+            add.metadata.reserve(trait.metadata.size());
+            for (const auto& md : trait.metadata)
+            {
+                add.metadata.emplace_back(metadatas[md]);
+            }
+            ret.emplace_back(std::move(add));
+        }
+        return ret;
+    };
+
+    const auto convertInstance = [&](const ABC::Instance& instance) {
+        Instance ret;
+        ret.name        = multinames[instance.name];
+        ret.superName   = multinames[instance.superName];
+        ret.flags       = instance.flags;
+        ret.protectedNs = namespaces[instance.protectedNs];
+        ret.interfaces.reserve(instance.interfaces.size());
+        for (const auto& interface : instance.interfaces)
+        {
+            ret.interfaces.emplace_back(multinames[interface]);
+        }
+        ret.iinit  = getMethod(instance.iinit);
+        ret.traits = convertTraits(instance.traits);
+        return ret;
+    };
+
+    const auto convertClass = [&](const ABC::Class& clazz, uint32_t i) {
+        classSet[i] = true;
+        return std::shared_ptr<Class>(
+            new Class{getMethod(clazz.cinit), convertTraits(clazz.traits), instances[i]});
+    };
+
+    const auto convertScript = [&](const ABC::Script& script) {
+        return Script{getMethod(script.sinit), convertTraits(script.traits)};
+    };
+
+    const auto convertInstruction = [&](const ABC::Instruction instruction) {
+        Instruction ret;
+        ret.opcode = instruction.opcode;
+        ret.arguments.reserve(instruction.arguments.size());
+
+        for (size_t i = 0; i < instruction.arguments.size(); i++)
+        {
+            Instruction::Argument arg;
+            switch (OPCode_Info[(uint8_t)instruction.opcode].second[i])
+            {
+                case OPCodeArgumentType::Unknown:
+                    throw StringException(std::string("Don't know how to convert OP_") +
+                                          OPCode_Info[(uint8_t)instruction.opcode].first);
+
+                case OPCodeArgumentType::ByteLiteral:
+                    arg.bytev(instruction.arguments[i].bytev());
+                    break;
+                case OPCodeArgumentType::UByteLiteral:
+                    arg.ubytev(instruction.arguments[i].ubytev());
+                    break;
+                case OPCodeArgumentType::IntLiteral:
+                    arg.intv(instruction.arguments[i].intv());
+                    break;
+                case OPCodeArgumentType::UIntLiteral:
+                    arg.uintv(instruction.arguments[i].uintv());
+                    break;
+
+                case OPCodeArgumentType::Int:
+                    arg.intv(abc.ints[instruction.arguments[i].index()]);
+                    break;
+                case OPCodeArgumentType::UInt:
+                    arg.uintv(abc.uints[instruction.arguments[i].index()]);
+                    break;
+                case OPCodeArgumentType::Double:
+                    arg.doublev(abc.doubles[instruction.arguments[i].index()]);
+                    break;
+                case OPCodeArgumentType::String:
+                    arg.stringv(abc.strings[instruction.arguments[i].index()]);
+                    break;
+                case OPCodeArgumentType::Namespace:
+                    arg.namespacev(instruction.arguments[i].index() < namespaces.size()
+                                       ? namespaces[instruction.arguments[i].index()]
+                                       : Namespace{});
+                    break;
+                case OPCodeArgumentType::Multiname:
+                    arg.multinamev(instruction.arguments[i].index() < multinames.size()
+                                       ? multinames[instruction.arguments[i].index()]
+                                       : Multiname{});
+                    break;
+                case OPCodeArgumentType::Class:
+                    arg.classv(instruction.arguments[i].index() < classes.size()
+                                   ? classes[instruction.arguments[i].index()]
+                                   : nullptr);
+                    break;
+                case OPCodeArgumentType::Method:
+                    arg.methodv(instruction.arguments[i].index() < methods.size()
+                                    ? methods[instruction.arguments[i].index()]
+                                    : nullptr);
+                    break;
+
+                case OPCodeArgumentType::JumpTarget:
+                case OPCodeArgumentType::SwitchDefaultTarget:
+                    arg.jumpTarget(instruction.arguments[i].jumpTarget());
+                    break;
+
+                case OPCodeArgumentType::SwitchTargets:
+                    arg.switchTargets(instruction.arguments[i].switchTargets());
+                    break;
+            }
+            ret.arguments.emplace_back(std::move(arg));
+        }
+        return ret;
+    };
+
+    const auto convertBody = [&](const ABC::MethodBody& body) {
+        MethodBody ret;
+        ret.method         = methods[body.method];
+        ret.maxStack       = body.maxStack;
+        ret.localCount     = body.localCount;
+        ret.initScopeDepth = body.initScopeDepth;
+        ret.maxScopeDepth  = body.maxScopeDepth;
+        ret.instructions.reserve(body.instructions.size());
+        for (const auto& instruction : body.instructions)
+        {
+            ret.instructions.emplace_back(convertInstruction(instruction));
+        }
+        ret.exceptions.reserve(ret.exceptions.size());
+        for (const auto& exception : body.exceptions)
+        {
+            ret.exceptions.emplace_back(exception.from, exception.to, exception.target,
+                multinames[exception.excType], multinames[exception.varName]);
+        }
+        ret.traits = convertTraits(body.traits);
+        ret.errors = body.errors;
+        return ret;
+    };
+
+    asp.minorVersion = abc.minorVersion;
+    asp.majorVersion = abc.majorVersion;
+
+    namespaces.reserve(abc.namespaces.size());
+    namespaceSets.reserve(abc.namespaceSets.size());
+    multinames.reserve(abc.multinames.size());
+    methods.reserve(abc.methods.size());
+    metadatas.reserve(abc.metadata.size());
+    instances.reserve(abc.instances.size());
+    classes.reserve(abc.classes.size());
+    asp.scripts.reserve(abc.scripts.size());
+
+    classSet.resize(abc.classes.size(), false);
+    classAdded.resize(abc.instances.size(), false);
+    methodAdded.resize(abc.methods.size(), false);
+
+    namespaces.emplace_back();
+    for (size_t i = 1; i < abc.namespaces.size(); i++)
+    {
+        namespaces.emplace_back(convertNamespace(abc.namespaces[i], i));
+    }
+
+    namespaceSets.emplace_back();
+    for (size_t i = 1; i < abc.namespaceSets.size(); i++)
+    {
+        namespaceSets.emplace_back(convertNamespaceSet(abc.namespaceSets[i]));
+    }
+
+    multinames.emplace_back();
+    for (size_t i = 1; i < abc.multinames.size(); i++)
+    {
+        multinames.emplace_back(convertMultiname(abc.multinames[i]));
+    }
+    for (size_t i = 1; i < abc.multinames.size(); i++)
+    {
+        postConvertMultiname(abc.multinames[i], multinames[i]);
+    }
+
+    for (size_t i = 0; i < abc.methods.size(); i++)
+    {
+        methods.emplace_back(convertMethod(abc.methods[i], i));
+    }
+
+    for (size_t i = 0; i < abc.metadata.size(); i++)
+    {
+        metadatas.emplace_back(convertMetadata(abc.metadata[i]));
+    }
+
+    for (size_t i = 0; i < abc.instances.size(); i++)
+    {
+        instances.emplace_back(convertInstance(abc.instances[i]));
+    }
+
+    for (size_t i = 0; i < abc.classes.size(); i++)
+    {
+        classes.emplace_back(convertClass(abc.classes[i], i));
+    }
+
+    for (size_t i = 0; i < abc.scripts.size(); i++)
+    {
+        asp.scripts.emplace_back(convertScript(abc.scripts[i]));
+    }
+
+    for (size_t i = 0; i < abc.bodies.size(); i++)
+    {
+        methods[abc.bodies[i].method]->vbody = convertBody(abc.bodies[i]);
+    }
+
+    for (size_t i = 0; i < classAdded.size(); i++)
+    {
+        if (!classAdded[i])
+        {
+            asp.orphanClasses.emplace_back(classes[i]);
+        }
+    }
+
+    for (size_t i = 0; i < methodAdded.size(); i++)
+    {
+        if (!methodAdded[i])
+        {
+            asp.orphanMethods.emplace_back(methods[i]);
+        }
+    }
+
+    return asp;
+}
+
+ABC::ABCFile ASASM::ASProgram::toABC()
+{
+    return AStoABC(*this).abc;
+}
diff --git a/Native/BytecodeEditor/source/BytecodeEditor.cpp b/Native/BytecodeEditor/source/BytecodeEditor.cpp
new file mode 100644
index 0000000..34ec55b
--- /dev/null
+++ b/Native/BytecodeEditor/source/BytecodeEditor.cpp
@@ -0,0 +1,228 @@
+#include "BytecodeEditor.hpp"
+#include "ABC/ABCReader.hpp"
+#include "ABC/ABCWriter.hpp"
+#include "Assembler.hpp"
+#include "Disassembler.hpp"
+#include "SWF/SWFFile.hpp"
+
+#define FAIL_ASYNC(x)                                                                              \
+    m_taskResult = x;                                                                              \
+    FREDispatchStatusEventAsync(ctx, (const uint8_t*)"Task complete", (const uint8_t*)"ERROR")
+
+#define SUCCEED_ASYNC(x)                                                                           \
+    m_taskResult = x;                                                                              \
+    FREDispatchStatusEventAsync(ctx, (const uint8_t*)"Task complete", (const uint8_t*)"SUCCESS")
+
+FREObject BytecodeEditor::disassemble()
+{
+    if (runningTask.joinable())
+    {
+        FAIL("Already running a task");
+    }
+
+    if (!currentSWF)
+    {
+        FAIL("No SWF data specified to disassemble");
+    }
+
+    try
+    {
+        auto strings = Disassembler::Disassembler(
+            ASASM::ASProgram::fromABC(ABC::ABCReader(currentSWF->abcData()).abc()))
+                           .disassemble();
+
+        FREObject ret;
+        DO_OR_FAIL("Failed to create return object",
+            FRENewObject((uint8_t*)"Object", 0, nullptr, &ret, nullptr));
+
+        for (const auto& file : strings)
+        {
+            FREObject str;
+            DO_OR_FAIL("Failed to create data string", FREString(file.second, &str));
+            DO_OR_FAIL("Failed to set data",
+                FRESetObjectProperty(ret, (const uint8_t*)file.first.c_str(), str, nullptr));
+        }
+
+        return ret;
+    }
+    catch (std::exception& e)
+    {
+        FAIL(std::string("Exception during disassembly: ") + e.what());
+    }
+}
+
+FREObject BytecodeEditor::assemble(std::unordered_map<std::string, std::string>&& strings)
+{
+    if (runningTask.joinable())
+    {
+        FAIL("Already running a task");
+    }
+
+    if (!currentSWF)
+    {
+        FAIL("No SWF data specified to reassemble");
+    }
+    std::vector<uint8_t> data =
+        std::move(ABC::ABCWriter(Assembler::assemble(strings).toABC()).data());
+
+    currentSWF->replaceABCData(data.data(), data.size());
+
+    FREObject lengthObj;
+    DO_OR_FAIL("Failed to create length object",
+        FRENewObjectFromUint32(currentSWF->getFullSize(), &lengthObj));
+
+    FREObject bytearrayObj;
+    DO_OR_FAIL("Failed to create returned bytearray",
+        FRENewObject((const uint8_t*)"flash.utils.ByteArray", 0, nullptr, &bytearrayObj, nullptr));
+
+    DO_OR_FAIL("Failed to set returned bytearray length to required size",
+        FRESetObjectProperty(bytearrayObj, (const uint8_t*)"length", lengthObj, nullptr));
+
+    FREByteArray ba;
+    DO_OR_FAIL("Failed to acquire bytearray", FREAcquireByteArray(bytearrayObj, &ba));
+
+    currentSWF->writeTo(ba.bytes);
+    DO_OR_FAIL("Failed to release bytearray", FREReleaseByteArray(bytearrayObj));
+
+    return bytearrayObj;
+}
+
+FREObject BytecodeEditor::disassembleAsync()
+{
+    if (runningTask.joinable())
+    {
+        FAIL("Already running a task");
+    }
+
+    runningTask = std::jthread([this] {
+        if (!currentSWF)
+        {
+            FAIL_ASYNC("No SWF data specified to disassemble");
+        }
+
+        try
+        {
+            SUCCEED_ASYNC(Disassembler::Disassembler(
+                ASASM::ASProgram::fromABC(ABC::ABCReader(currentSWF->abcData()).abc()))
+                              .disassemble());
+        }
+        catch (std::exception& e)
+        {
+            FAIL_ASYNC(std::string("Exception during disassembly: ") + e.what());
+        }
+    });
+
+    FREObject ret;
+    DO_OR_FAIL("Failed to create success boolean", FRENewObjectFromBool(1, &ret));
+    return ret;
+}
+
+FREObject BytecodeEditor::assembleAsync(std::unordered_map<std::string, std::string>&& strings)
+{
+    if (runningTask.joinable())
+    {
+        FAIL("Already running a task");
+    }
+
+    runningTask = std::jthread([this, strings = std::move(strings)] {
+        if (!currentSWF)
+        {
+            FAIL_ASYNC("No SWF data specified to reassemble");
+        }
+        try
+        {
+            std::vector<uint8_t> data =
+                std::move(ABC::ABCWriter(Assembler::assemble(strings).toABC()).data());
+
+            currentSWF->replaceABCData(data.data(), data.size());
+
+            std::vector<uint8_t> finalData(currentSWF->getFullSize());
+
+            currentSWF->writeTo(finalData.data());
+
+            SUCCEED_ASYNC(std::move(finalData));
+        }
+        catch (std::exception& e)
+        {
+            FAIL_ASYNC(std::string("Exception during assembly: ") + e.what());
+        }
+    });
+
+    FREObject ret;
+    DO_OR_FAIL("Failed to create success boolean", FRENewObjectFromBool(1, &ret));
+    return ret;
+}
+
+#undef FAIL_RETURN
+#define FAIL_RETURN(x)                                                                             \
+    do                                                                                             \
+    {                                                                                              \
+        m_taskResult = std::monostate{};                                                           \
+        return x;                                                                                  \
+    } while (false)
+
+FREObject BytecodeEditor::taskResult()
+{
+    if (runningTask.joinable())
+    {
+        runningTask.join();
+    }
+    switch (m_taskResult.index())
+    {
+        case 0:
+            return nullptr;
+        case 1:
+        {
+            FREObject r;
+            FREString(std::get<1>(m_taskResult), &r);
+            m_taskResult = std::monostate{};
+            return r;
+        }
+        case 2:
+        {
+            const auto& strings = std::get<2>(m_taskResult);
+
+            FREObject ret;
+            DO_OR_FAIL("Failed to create return object",
+                FRENewObject((uint8_t*)"Object", 0, nullptr, &ret, nullptr));
+
+            for (const auto& file : strings)
+            {
+                FREObject str;
+                DO_OR_FAIL("Failed to create data string", FREString(file.second, &str));
+                DO_OR_FAIL("Failed to set data",
+                    FRESetObjectProperty(ret, (const uint8_t*)file.first.c_str(), str, nullptr));
+            }
+
+            m_taskResult = std::monostate{};
+            return ret;
+        }
+        case 3:
+        {
+            const auto& data = std::get<3>(m_taskResult);
+
+            FREObject lengthObj;
+            DO_OR_FAIL(
+                "Failed to create length object", FRENewObjectFromUint32(data.size(), &lengthObj));
+
+            FREObject bytearrayObj;
+            DO_OR_FAIL("Failed to create returned bytearray",
+                FRENewObject(
+                    (const uint8_t*)"flash.utils.ByteArray", 0, nullptr, &bytearrayObj, nullptr));
+
+            DO_OR_FAIL("Failed to set returned bytearray length to required size",
+                FRESetObjectProperty(bytearrayObj, (const uint8_t*)"length", lengthObj, nullptr));
+
+            FREByteArray ba;
+            DO_OR_FAIL("Failed to acquire bytearray", FREAcquireByteArray(bytearrayObj, &ba));
+
+            std::copy(data.begin(), data.end(), ba.bytes);
+            DO_OR_FAIL("Failed to release bytearray", FREReleaseByteArray(bytearrayObj));
+
+            m_taskResult = std::monostate{};
+            return bytearrayObj;
+        }
+        default:
+            FAIL("Invalid task result index");
+    }
+}
\ No newline at end of file
diff --git a/Native/BytecodeEditor/source/Test.cpp.disabled b/Native/BytecodeEditor/source/Test.cpp.disabled
new file mode 100644
index 0000000..69c71a9
--- /dev/null
+++ b/Native/BytecodeEditor/source/Test.cpp.disabled
@@ -0,0 +1,120 @@
+#if defined(WIN32) && !defined(NDEBUG)
+#include "ABC/ABCReader.hpp"
+#include "ABC/ABCWriter.hpp"
+#include "ASASM/ASProgram.hpp"
+#include "Assembler.hpp"
+#include "BytecodeEditor.hpp"
+#include "Disassembler.hpp"
+#include "SWF/SWFFile.hpp"
+#include <exception>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <windows.h>
+
+void testdisassemble()
+{
+    FILE* file = fopen("test.swf", "rb");
+    fseek(file, 0, SEEK_END);
+    const size_t size = ftell(file);
+    fseek(file, 0, SEEK_SET);
+
+    std::vector<uint8_t> data(size, 0);
+    fread(data.data(), 1, size, file);
+    fclose(file);
+
+    std::unordered_map<std::string, std::string> disassembled;
+
+    {
+        SWF::SWFFile swf{std::move(data)};
+
+        auto abcData = swf.abcData();
+
+        ABC::ABCReader reader(abcData.first, abcData.second);
+        const auto& abc          = reader.abc();
+        ASASM::ASProgram program = ASASM::ASProgram::fromABC(abc);
+        disassembled             = Disassembler(program).disassemble();
+    }
+
+    file = fopen("out.basasm", "wb");
+    for (const auto& pair : disassembled)
+    {
+        fwrite(pair.first.c_str(), 1, pair.first.size(), file);
+        fputc('\0', file);
+        fwrite(pair.second.c_str(), 1, pair.second.size(), file);
+        fputc('\0', file);
+    }
+    fclose(file);
+}
+
+void testreassemble()
+{
+    std::unordered_map<std::string, std::string> asasmFiles;
+    FILE* file = fopen("out.basasm", "rb");
+    fseek(file, 0, SEEK_END);
+    size_t size = ftell(file);
+    fseek(file, 0, SEEK_SET);
+
+    std::vector<char> stringData(size);
+    fread(stringData.data(), 1, stringData.size(), file);
+    fclose(file);
+
+    size_t currOffset = 0;
+
+    static auto readNTString = [&stringData, &currOffset] {
+        std::string ret(stringData.data() + currOffset);
+        currOffset += ret.size() + 1;
+        return ret;
+    };
+
+    while (currOffset != stringData.size())
+    {
+        std::string key   = readNTString();
+        std::string value = readNTString();
+
+        asasmFiles.emplace(key, value);
+    }
+
+    std::vector<uint8_t> abcData =
+        std::move(ABC::ABCWriter(Assembler::assemble(asasmFiles).toABC()).data());
+
+    file = fopen("test.swf", "rb");
+    fseek(file, 0, SEEK_END);
+    size = ftell(file);
+    fseek(file, 0, SEEK_SET);
+
+    std::vector<uint8_t> data(size, 0);
+    fread(data.data(), 1, size, file);
+    fclose(file);
+
+    std::vector<uint8_t> outData;
+
+    {
+        SWF::SWFFile swf{std::move(data)};
+        swf.replaceABCData(abcData.data(), abcData.size());
+
+        outData.resize(swf.getFullSize());
+        swf.writeTo(outData.data());
+    }
+
+    file = fopen("out.swf", "wb");
+    fwrite(outData.data(), 1, outData.size(), file);
+    fclose(file);
+}
+
+extern "C" __declspec(dllexport) void WINAPI
+    HelperFunc(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
+{
+    try
+    {
+        // testdisassemble();
+        testreassemble();
+    }
+    catch (std::exception& e)
+    {
+        MessageBoxA(NULL, e.what(), "", MB_OK);
+    }
+}
+#endif
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3486bd7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# ANEBytecodeEditor
+To compile and build the .ane, run package.bat with the environment variable AIRSDK set to the location of your AIR SDK
diff --git a/descriptor.xml b/descriptor.xml
new file mode 100644
index 0000000..371583f
--- /dev/null
+++ b/descriptor.xml
@@ -0,0 +1,13 @@
+<extension xmlns="http://ns.adobe.com/air/extension/2.5">
+	<id>com.cff.anebe.ANEBytecodeEditor</id>
+	<versionNumber>0.5</versionNumber>
+	<platforms>
+		<platform name="Windows-x86">
+			<applicationDeployment>
+				<nativeLibrary>ANEBytecodeEditor.dll</nativeLibrary>
+				<initializer>ExtInitializerANEBytecodeEditor</initializer>
+				<finalizer>ExtFinalizerANEBytecodeEditor</finalizer>
+			</applicationDeployment>
+		</platform>
+    </platforms>
+</extension>
diff --git a/package.bat b/package.bat
new file mode 100644
index 0000000..f6a897b
--- /dev/null
+++ b/package.bat
@@ -0,0 +1,7 @@
+call %AIRSDK%\bin\compc.bat +configname=air -source-path AS3/src -include-sources AS3/src -swf-version=11 -output ANEBytecodeEditor.swc -debug=true
+copy /Y ANEBytecodeEditor.swc ANEBytecodeEditor.zip
+powershell -command "Expand-Archive -Force ANEBytecodeEditor.zip ."
+call %AIRSDK%\bin\adt.bat -package -target ane ANEBytecodeEditor.ane descriptor.xml -platform Windows-x86 library.swf ANEBytecodeEditor.dll -swc ANEBytecodeEditor.swc
+del ANEBytecodeEditor.zip
+del library.swf
+del catalog.xml
\ No newline at end of file