diff --git a/src/.idea/.idea.L5Sharp/.idea/workspace.xml b/src/.idea/.idea.L5Sharp/.idea/workspace.xml
index dfa42dce..e8308295 100644
--- a/src/.idea/.idea.L5Sharp/.idea/workspace.xml
+++ b/src/.idea/.idea.L5Sharp/.idea/workspace.xml
@@ -2,49 +2,48 @@
 <project version="4">
   <component name="AutoGeneratedRunConfigurationManager">
     <projectFile>../../tests/TestConsole/TestConsole.csproj</projectFile>
+    <projectFile>../tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj</projectFile>
   </component>
   <component name="AutoImportSettings">
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="752cc344-96c2-4c02-b648-9fe9aa3d66f8" name="Changes" comment="Added new Keyword.cs and removed Function.cs since Instructions contained all of them. Continuing development for LogixCode.cs derivatives and their value types. Updated tests. Prepping to fix issues with serializer">
-      <change afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramStep.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/L5Sharp/Enums/ComponentType.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/L5Sharp/ILogixReferencable.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/L5Sharp/LogixReference.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XReferenceTests.cs" afterDir="false" />
+    <list default="true" id="752cc344-96c2-4c02-b648-9fe9aa3d66f8" name="Changes" comment="">
+      <change afterPath="$PROJECT_DIR$/../tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/../tests/L5Sharp.Benchmarks/NeutralTextBenchmarks.cs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/../tests/L5Sharp.Benchmarks/Program.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/.idea.L5Sharp/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.L5Sharp/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Common/ComponentKey.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Common/ComponentKey.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp.sln" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp.sln" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp.sln.DotSettings" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp.sln.DotSettings" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Common/Argument.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Common/Argument.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Common/NeutralText.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Common/NeutralText.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Common/TagName.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Common/TagName.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Components/AddOnInstruction.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Components/AddOnInstruction.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Components/DataType.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Components/DataType.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Components/Routine.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Components/Routine.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Components/Tag.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Components/Tag.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramBlock.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramBlock.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramConnector.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramConnector.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramElement.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramElement.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramFunction.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramFunction.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramInstruction.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramInstruction.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramReference.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramReference.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramRoutine.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramRoutine.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/DiagramText.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/DiagramText.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/Line.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/Line.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/Rung.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/Rung.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Elements/Sheet.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Elements/Sheet.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/RoutineType.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Enums/RoutineType.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/Scope.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Enums/Scope.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/L5X.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/L5X.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/Instruction.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Common/Instruction.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/Keyword.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Enums/Keyword.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/Operator.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Enums/Operator.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Enums/Radix.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Enums/Radix.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/LogixCode.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/LogixCode.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/LogixComponent.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/LogixComponent.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/L5Sharp/LogixSerializer.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/LogixSerializer.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/LogixReference.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/LogixReference.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Types/Atomic.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Types/Atomic.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/L5Sharp/Utilities/L5XExtensions.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Utilities/L5XExtensions.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/L5Sharp/Utilities/L5XParser.cs" beforeDir="false" afterPath="$PROJECT_DIR$/L5Sharp/Utilities/L5XParser.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Samples/Known.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Samples/Known.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Elements/LineTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Elements/LineTests.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Elements/SheetTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Elements/SheetTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/ArgumentTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/ArgumentTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/NeutralTextTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/NeutralTextTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/TagNameTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/TagNameTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Enums/InstructionTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Common/InstructionTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Enums/KeywordTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/Enums/KeywordTests.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XBasicTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XBasicTests.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XDataTypeTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XDataTypeTests.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XTagTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XTagTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XTemplateTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/L5XTemplateTests.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/ProofTesting.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/ProofTesting.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../tests/L5Sharp.Tests/TagPerformanceTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/../tests/L5Sharp.Tests/TagPerformanceTests.cs" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -157,6 +156,26 @@
     ]
   }
 }]]></component>
+  <component name="RunManager">
+    <configuration name="L5Sharp.Benchmarks" type="DotNetProject" factoryName=".NET Project">
+      <option name="EXE_PATH" value="" />
+      <option name="PROGRAM_PARAMETERS" value="" />
+      <option name="WORKING_DIRECTORY" value="" />
+      <option name="PASS_PARENT_ENVS" value="1" />
+      <option name="USE_EXTERNAL_CONSOLE" value="0" />
+      <option name="USE_MONO" value="0" />
+      <option name="RUNTIME_ARGUMENTS" value="" />
+      <option name="PROJECT_PATH" value="$PROJECT_DIR$/../tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj" />
+      <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
+      <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
+      <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
+      <option name="PROJECT_KIND" value="DotNetCore" />
+      <option name="PROJECT_TFM" value="" />
+      <method v="2">
+        <option name="Build" />
+      </method>
+    </configuration>
+  </component>
   <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
   <component name="SvnConfiguration">
     <configuration>C:\Users\tnunnink\AppData\Roaming\Subversion</configuration>
@@ -392,7 +411,7 @@
       <workItem from="1692213662519" duration="30729000" />
       <workItem from="1693231547412" duration="3665000" />
       <workItem from="1695256063268" duration="92590000" />
-      <workItem from="1696620242847" duration="160135000" />
+      <workItem from="1696620242847" duration="235512000" />
     </task>
     <task id="LOCAL-00199" summary="cleared warnings. preping to merge changes.">
       <created>1677621948966</created>
@@ -737,7 +756,7 @@
       <option name="project" value="LOCAL" />
       <updated>1687451515386</updated>
     </task>
-    <option name="localTasksCounter" value="305" />
+    <option name="localTasksCounter" value="308" />
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">
@@ -747,7 +766,7 @@
     <option name="coveragePercentColumnWidth" value="33" />
     <option name="sortOrder" value="DESCENDING" />
     <option name="sortedColumn" value="1" />
-    <option name="symbolColumnWidth" value="322" />
+    <option name="symbolColumnWidth" value="319" />
     <coverage-tree-state>
       <expand />
       <select />
@@ -773,9 +792,6 @@
       <path value="$PROJECT_DIR$/../.." />
     </ignored-roots>
     <option name="CLEAR_INITIAL_COMMIT_MESSAGE" value="true" />
-    <MESSAGE value="left align table" />
-    <MESSAGE value="README.md update" />
-    <MESSAGE value="Updated test project namespace. Fixed bug with StringType.cs not correctly parsing ASCII formatted string values. Removed Tag comment and combine logic for getting and setting value in the Tag Description property." />
     <MESSAGE value="Continued to revise the StringType.cs to account for ASCII formatted string values. Fixed tests that were broken from changes. Reorg." />
     <MESSAGE value="update version" />
     <MESSAGE value="fixed README.md" />
@@ -798,7 +814,10 @@
     <MESSAGE value="Removed generic parameter from LogixComponent.cs. to simplify patter matching and type constraints. It was really only needed for methods that are now moved to LogixElement." />
     <MESSAGE value="Added elements for the FBD routine type and the new LogixCode.cs to group things like Rung, Line, Sheet into a single category of content that can be identified and analyzed for tag names and instructions. This is on a path towards making cross referencing of components work." />
     <MESSAGE value="Added new Keyword.cs and removed Function.cs since Instructions contained all of them. Continuing development for LogixCode.cs derivatives and their value types. Updated tests. Prepping to fix issues with serializer" />
-    <option name="LAST_COMMIT_MESSAGE" value="Added new Keyword.cs and removed Function.cs since Instructions contained all of them. Continuing development for LogixCode.cs derivatives and their value types. Updated tests. Prepping to fix issues with serializer" />
+    <MESSAGE value="Lots of addition to LogixCode.cs elements and referencing. Initial proof on concept is working well. Need to finish all internal indexing support and testing. Need to revisit NeutralText. Need to finish remaining routine content elements." />
+    <MESSAGE value="Reorg and documentation of some classes. Finishing primary tasks for new referencing feature. Starting to revisit NeutralText." />
+    <MESSAGE value="Starting updates for Instruction.cs. Added Argument.cs. Attempting to make instruction not a enum type but a common value type with arguments." />
+    <option name="LAST_COMMIT_MESSAGE" value="Starting updates for Instruction.cs. Added Argument.cs. Attempting to make instruction not a enum type but a common value type with arguments." />
   </component>
   <component name="XDebuggerManager">
     <breakpoint-manager>
@@ -820,39 +839,26 @@
           <line>60</line>
           <properties documentPath="C:\Projects\L5Sharp\tests\L5Sharp.Tests\L5XTagTests.cs" initialLine="60" containingFunctionPresentation="Method 'References_AgainstAllTags_ShouldNotBeEmpty'">
             <startOffsets>
-              <option value="1432" />
+              <option value="1431" />
             </startOffsets>
             <endOffsets>
-              <option value="1465" />
+              <option value="1464" />
             </endOffsets>
           </properties>
           <option name="timeStamp" value="49" />
         </line-breakpoint>
         <line-breakpoint enabled="true" type="DotNet Breakpoints">
-          <url>file://$PROJECT_DIR$/L5Sharp/L5X.cs</url>
-          <line>544</line>
-          <properties documentPath="C:\Projects\L5Sharp\src\L5Sharp\L5X.cs" initialLine="546" containingFunctionPresentation="Method 'OnContentChanging'">
-            <startOffsets>
-              <option value="28611" />
-            </startOffsets>
-            <endOffsets>
-              <option value="28612" />
-            </endOffsets>
-          </properties>
-          <option name="timeStamp" value="71" />
-        </line-breakpoint>
-        <line-breakpoint enabled="true" type="DotNet Breakpoints">
-          <url>file://$PROJECT_DIR$/L5Sharp/L5X.cs</url>
-          <line>561</line>
-          <properties documentPath="C:\Projects\L5Sharp\src\L5Sharp\L5X.cs" initialLine="556" containingFunctionPresentation="Method 'OnContentChanged'">
+          <url>file://$PROJECT_DIR$/../tests/L5Sharp.Tests/ProofTesting.cs</url>
+          <line>45</line>
+          <properties documentPath="C:\Projects\L5Sharp\tests\L5Sharp.Tests\ProofTesting.cs" initialLine="45" containingFunctionPresentation="Method 'Query'">
             <startOffsets>
-              <option value="29294" />
+              <option value="933" />
             </startOffsets>
             <endOffsets>
-              <option value="29295" />
+              <option value="961" />
             </endOffsets>
           </properties>
-          <option name="timeStamp" value="74" />
+          <option name="timeStamp" value="118" />
         </line-breakpoint>
       </breakpoints>
     </breakpoint-manager>
@@ -863,6 +869,7 @@
         <PinnedItemInfo parentTag="Frame#L5Sharp.Components.DataType.References" memberName="reference" />
         <PinnedItemInfo parentTag="Frame#L5Sharp.Tests.LogixContentTests.Query_TagsInMovInstructions_ShouldReturnsLotsOfTagNames" memberName="references" />
         <PinnedItemInfo parentTag="Frame#L5Sharp.Tests.LogixContentAgainstTemplateTests.Instructions_WhenCalled_ShouldNotBeEmpty" memberName="components" />
+        <PinnedItemInfo parentTag="Frame#L5Sharp.L5X.AddReferences" memberName="this" />
         <PinnedItemInfo parentTag="Type#L5Sharp.Types.Member" memberName="DataType" />
         <PinnedItemInfo parentTag="Frame#L5Sharp.Tests.L5XDataTypeTests.References_WhenCalled_ShouldReturnElementsWithExpectedDataType" memberName="this" />
         <PinnedItemInfo parentTag="Type#L5Sharp.L5X" memberName="Programs" />
@@ -888,6 +895,9 @@
         <watch expression="new System.Collections.Generic.ICollectionDebugView&lt;L5Sharp.LogixElement&gt;(references).Items[3]" />
         <watch expression="new System.Collections.Generic.ICollectionDebugView&lt;&lt;&gt;f__AnonymousType2&lt;L5Sharp.Common.TagName, System.Collections.Generic.IEnumerable&lt;L5Sharp.LogixElement&gt;&gt;&gt;(references).Items[55]" />
         <watch expression="new System.Collections.Generic.ICollectionDebugView&lt;&lt;&gt;f__AnonymousType2&lt;L5Sharp.Common.TagName, System.Collections.Generic.IEnumerable&lt;L5Sharp.LogixElement&gt;&gt;&gt;(references).Items[55]" />
+        <watch expression="new System.Collections.Generic.IDictionaryDebugView&lt;string, System.Xml.Linq.XElement&gt;(new System.Collections.Generic.IDictionaryDebugView&lt;L5Sharp.Common.ComponentKey, System.Collections.Generic.Dictionary&lt;string, System.Xml.Linq.XElement&gt;&gt;(l5X._componentIndex).Items[743].Value).Items[0]" />
+        <watch expression="new System.Collections.Generic.IDictionaryDebugView&lt;string, System.Xml.Linq.XElement&gt;(new System.Collections.Generic.IDictionaryDebugView&lt;L5Sharp.Common.ComponentKey, System.Collections.Generic.Dictionary&lt;string, System.Xml.Linq.XElement&gt;&gt;(l5X._componentIndex).Items[743].Value).Items[0]" />
+        <watch expression="l5X._referenceIndex" />
       </configuration>
     </watches-manager>
   </component>
diff --git a/src/L5Sharp.sln b/src/L5Sharp.sln
index 641ee814..3a826f92 100644
--- a/src/L5Sharp.sln
+++ b/src/L5Sharp.sln
@@ -8,6 +8,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "L5Sharp.Samples", "..\tests
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "L5Sharp", "L5Sharp\L5Sharp.csproj", "{927D481B-CB0E-4FA5-A5DC-98D8ECE5EF56}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "L5Sharp.Benchmarks", "..\tests\L5Sharp.Benchmarks\L5Sharp.Benchmarks.csproj", "{F52CE1E1-B8AC-431B-901F-55824D6F5E40}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -26,9 +28,14 @@ Global
 		{927D481B-CB0E-4FA5-A5DC-98D8ECE5EF56}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{927D481B-CB0E-4FA5-A5DC-98D8ECE5EF56}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{927D481B-CB0E-4FA5-A5DC-98D8ECE5EF56}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F52CE1E1-B8AC-431B-901F-55824D6F5E40}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F52CE1E1-B8AC-431B-901F-55824D6F5E40}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F52CE1E1-B8AC-431B-901F-55824D6F5E40}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F52CE1E1-B8AC-431B-901F-55824D6F5E40}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{FED5FACA-5568-4A3F-94C0-536D9E36CA26} = {337B58B2-5647-4088-8CB3-50B3752B04D8}
 		{EBD410F5-C4E8-4D12-86B4-08B190B50B63} = {337B58B2-5647-4088-8CB3-50B3752B04D8}
+		{F52CE1E1-B8AC-431B-901F-55824D6F5E40} = {337B58B2-5647-4088-8CB3-50B3752B04D8}
 	EndGlobalSection
 EndGlobal
diff --git a/src/L5Sharp.sln.DotSettings b/src/L5Sharp.sln.DotSettings
index 0e7478b9..ec720474 100644
--- a/src/L5Sharp.sln.DotSettings
+++ b/src/L5Sharp.sln.DotSettings
@@ -22,6 +22,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=INT/@EntryIndexedValue">INT</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IO/@EntryIndexedValue">IO</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=LEN/@EntryIndexedValue">LEN</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=LINT/@EntryIndexedValue">LINT</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=LN/@EntryIndexedValue">LN</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=LOG/@EntryIndexedValue">LOG</s:String>
diff --git a/src/L5Sharp/Common/Argument.cs b/src/L5Sharp/Common/Argument.cs
index 1972cb00..b5ece7a1 100644
--- a/src/L5Sharp/Common/Argument.cs
+++ b/src/L5Sharp/Common/Argument.cs
@@ -12,36 +12,91 @@ public class Argument
     private readonly object _value;
 
     /// <summary>
-    /// Creates a new <see cref="Argument"/> wrapping the provided immediate atomic value.
+    /// Creates a new <see cref="Argument"/> wrapping the object value.
     /// </summary>
-    /// <param name="value">An <see cref="AtomicType"/> representing the argument.</param>
+    /// <param name="value">An object representing the argument.</param>
     /// <exception cref="ArgumentNullException"><c>value</c> is <c>null</c>.</exception>
-    private Argument(AtomicType value)
+    private Argument(object value)
     {
         _value = value ?? throw new ArgumentNullException(nameof(value));
     }
+    
+    /// <summary>
+    /// Indicates whether the argument is an immediate atomic value.
+    /// </summary>
+    /// <value><c>true</c> if the underlying value is an <see cref="AtomicType"/> object; Otherwise, <c>false</c>.</value>
+    public bool IsAtomic => _value is AtomicType;
 
     /// <summary>
-    /// Creates a new <see cref="Argument"/> wrapping the provided tag name reference.
+    /// Indicates whether the argument is an expression or combination of tag names, operators, and/or immediate values.
     /// </summary>
-    /// <param name="value">A <see cref="TagName"/> representing the argument.</param>
-    /// <exception cref="ArgumentNullException"><c>value</c> is <c>null</c>.</exception>
-    private Argument(TagName value)
-    {
-        _value = value ?? throw new ArgumentNullException(nameof(value));
-    }
+    /// <value><c>true</c> if the underlying value is a <see cref="NeutralText"/> instance wrapping a complex expression;
+    /// Otherwise, <c>false</c>.</value>
+    public bool IsExpression => _value is NeutralText;
 
     /// <summary>
-    /// Indicates whether the argument is an immediate atomic value.
+    /// Indicates whether the argument is an immediate value, either string literal or atomic value.
     /// </summary>
-    /// <value><c>true</c> if the underlying value is an <see cref="AtomicType"/> object; Otherwise, <c>false</c>.</value>
-    public bool IsImmediate => _value is AtomicType;
+    /// <value><c>true</c> if the underlying value is an <see cref="AtomicType"/> or <see cref="string"/> object;
+    /// Otherwise, <c>false</c>.</value>
+    public bool IsImmediate => _value is AtomicType or string;
 
     /// <summary>
     /// Indicates whether the argument is an tag name reference.
     /// </summary>
     /// <value><c>true</c> if the underlying value is a <see cref="TagName"/> object; Otherwise, <c>false</c>.</value>
     public bool IsTag => _value is TagName;
+    
+    /// <summary>
+    /// Indicates whether the argument is a literal string value with the single quote identifiers.
+    /// </summary>
+    /// <value><c>true</c> if the underlying value is an <see cref="string"/> object; Otherwise, <c>false</c>.</value>
+    public bool IsString => _value is string;
+
+    /// <summary>
+    /// Represents an unknown argument that can be found in certain instruction text.
+    /// </summary>
+    /// <value>A <see cref="Argument"/> representing an unknown parameter.</value>
+    /// <remarks>This is literally the '?' character, as often seen in the TIMER instruction arguments.</remarks>
+    public static Argument Unknown => new("?");
+    
+    /// <summary>
+    /// Represents an empty argument.
+    /// </summary>
+    /// <value>A <see cref="Argument"/> wrapping an empty string objet value.</value>
+    /// <remarks>
+    /// Some instruction have an empty/optional argument(s) (GSV) and therefore we need a way to represent
+    /// that value.
+    /// </remarks>
+    public static Argument Empty => new(string.Empty);
+
+    /// <summary>
+    /// Parses the string input into a valid <see cref="Argument"/> object.
+    /// </summary>
+    /// <param name="value">Teh string value to parse.</param>
+    /// <returns>A <see cref="Argument"/> representing the string input.</returns>
+    /// <exception cref="ArgumentException"><c>value</c> is null or empty</exception>
+    /// <remarks>This parse method expects the string to be an <see cref="AtomicType"/> immediate value,
+    /// a single <see cref="TagName"/> value, or an expression that can be represented as
+    /// <see cref="NeutralText"/> type.
+    /// </remarks>
+    public static Argument Parse(string? value)
+    {
+        //Empty value - lets not crash on empty or invalid arguments.
+        if (string.IsNullOrEmpty(value)) return Empty;
+        
+        //Unknown value - Can be found in TON instructions.
+        if (value == "?") return Unknown;
+
+        //Literal string value - We need to intercept this before the Atomic.TryParse method to prevent overflow.
+        if (value.StartsWith('\'') && value.EndsWith('\'')) return new Argument(value);
+
+        //Immediate atomic value
+        if (Atomic.TryParse(value, out var atomicType) && atomicType is not null) return new Argument(atomicType);
+
+        //TagName or Expression otherwise
+        return TagName.IsTag(value) ? new Argument(new TagName(value)) : new Argument(new NeutralText(value));
+    }
 
     /// <summary>
     /// Implicitly converts the provided <see cref="TagName"/> to an <see cref="Argument"/>.
@@ -53,9 +108,9 @@ private Argument(TagName value)
     /// <summary>
     /// Implicitly converts the provided <see cref="TagName"/> to an <see cref="Argument"/>.
     /// </summary>
-    /// <param name="tagName">The <see cref="TagName"/> object to convert.</param>
+    /// <param name="value">The <see cref="TagName"/> object to convert.</param>
     /// <returns>A <see cref="Argument"/> object containing the value of the tag name.</returns>
-    public static implicit operator Argument(string tagName) => new(new TagName(tagName));
+    public static implicit operator Argument(string value) => Parse(value);
 
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
@@ -70,14 +125,14 @@ private Argument(TagName value)
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(sbyte value) => new(new SINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(byte value) => new(new USINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
@@ -98,35 +153,35 @@ private Argument(TagName value)
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(int value) => new(new DINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(uint value) => new(new UDINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(long value) => new(new LINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(ulong value) => new(new ULINT(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
     /// <param name="value">The object value to convert.</param>
     /// <returns>An <see cref="Argument"/> containing the value of the provided object.</returns>
     public static implicit operator Argument(float value) => new(new REAL(value));
-    
+
     /// <summary>
     /// Implicitly converts the provided value to an <see cref="Argument"/>.
     /// </summary>
@@ -147,6 +202,13 @@ private Argument(TagName value)
     /// <param name="argument">The <see cref="Argument"/> object to convert.</param>
     /// <returns>A <see cref="AtomicType"/> object representing the value of the argument.</returns>
     public static explicit operator AtomicType(Argument argument) => (AtomicType) argument._value;
+    
+    /// <summary>
+    /// Explicitly converts the provided <see cref="Argument"/> to an <see cref="NeutralText"/>.
+    /// </summary>
+    /// <param name="argument">The <see cref="Argument"/> object to convert.</param>
+    /// <returns>A <see cref="NeutralText"/> object representing the value of the argument.</returns>
+    public static explicit operator NeutralText(Argument argument) => (NeutralText) argument._value;
 
     /// <inheritdoc />
     public override bool Equals(object? obj) => _value.Equals(obj);
diff --git a/src/L5Sharp/Enums/Instruction.cs b/src/L5Sharp/Common/Instruction.cs
similarity index 79%
rename from src/L5Sharp/Enums/Instruction.cs
rename to src/L5Sharp/Common/Instruction.cs
index b8f6dba4..a5c2bcea 100644
--- a/src/L5Sharp/Enums/Instruction.cs
+++ b/src/L5Sharp/Common/Instruction.cs
@@ -1,41 +1,61 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
-using L5Sharp.Common;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading;
+using JetBrains.Annotations;
+using L5Sharp.Utilities;
 
 // ReSharper disable IdentifierTypo
 // ReSharper disable InconsistentNaming
 // ReSharper disable CommentTypo
 
-namespace L5Sharp.Enums;
+namespace L5Sharp.Common;
 
 /// <summary>
 /// A class representing a instruction definition and ...
 /// </summary>
-public sealed class Instruction : LogixEnum<Instruction, string>
+[PublicAPI]
+public sealed class Instruction
 {
+    /// <summary>
+    /// Pattern for identifying any instruction and the contents of it's signature. This expression should
+    /// capture everything enclosed or between the instruction parentheses. This includes nested parenthesis.
+    /// This works on the assumption that the text has balanced opening/closing parentheses.
+    /// </summary>
+    public const string Pattern = @"[A-Za-z_]\w{1,39}\((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))\)";
+
+    /// <summary>
+    /// Pattern finds all text prior to opening parentheses, which is the instruction name or key that identifies
+    /// the instruction.
+    /// </summary>
+    private const string KeyPattern = @"[A-Za-z_]\w{1,39}(?=\()";
+    
     /// <summary>
     /// Captures all content within parentheses, including outer parentheses and nested parentheses, assuming they
     /// are balanced (number of opening equals number of closing).
     /// </summary>
     private const string SignaturePattern = @"\((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))\)";
+    
+    /// <summary>
+    /// The regex pattern for Logix tag names without starting and ending anchors.
+    /// This pattern also includes a negative lookahead for removing text prior to parenthesis (i.e. instruction keys)
+    /// Use this pattern for tag names within text, such as longer
+    /// </summary>
+    private const string TagNamePattern =
+        @"(?!\w*\()[A-Za-z_][\w+:]{1,39}(?:(?:\[\d+\]|\[\d+,\d+\]|\[\d+,\d+,\d+\])?(?:\.[A-Za-z_]\w{1,39})?)+(?:\.[0-9][0-9]?)?";
 
     /// <summary>
     /// Creates a new <see cref="Instruction"/> with the provided string key and regex signature pattern.
     /// </summary>
     /// <param name="key">The key identifier of the instruction.</param>
-    /// <param name="destructive">Optional bit indicating that the instruction is destructive. Default is <c>true</c>
-    /// as most instructions are destructive (update state).</param>
-    public Instruction(string key, bool destructive = true) : base(key, key)
-    {
-        Signature = $"{Name}{SignaturePattern}";
-        Destructive = destructive;
-        Arguments = Enumerable.Empty<Argument>();
-    }
-
-    private Instruction(string key, bool destructive, params Argument[] arguments) : base(key, key)
+    /// <param name="arguments"></param>
+    public Instruction(string key, params Argument[] arguments)
     {
-        Signature = $"{Name}{SignaturePattern}";
-        Destructive = destructive;
+        if (string.IsNullOrEmpty(key))
+            throw new ArgumentException("Instruction key cannot be null or empty.", nameof(key));
+        Key = key;
         Arguments = arguments;
     }
 
@@ -54,19 +74,139 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// </summary>
     public bool CallsTask => this == EVENT;
 
+    /// <summary>
+    /// Indicates whether the instruction is conditional or evaluates a certain condition to be true or false, in which
+    /// it directs the flow of the program to a different location.
+    /// </summary>
+    /// <value><c>true</c> if the instruction is conditional; Otherwise, <c>false</c>.</value>
+    /// <remarks>An example of a condition instruction is an <see cref="XIC"/>.</remarks>
+    public bool IsConditional => ConditionalKeys().Contains(Key);
+
+    /// <summary>
+    /// The unique identifier of the instruction instance.
+    /// </summary>
+    /// <value>
+    /// A <see cref="string"/> containing the short hand instruction key identifier (e.g. XIC/OTe).
+    /// For AOI this is the name of the component.
+    /// </value>
+    public string Key { get; }
+
     /// <summary>
     /// The signature or valid regex pattern of the instruction neutral text.
     /// </summary>
     /// <remarks>
     /// This format string represent a regex capture pattern to help parse <see cref="NeutralText"/> for the instruction.
     /// </remarks>
-    public string Signature { get; }
+    public string Signature => $"({string.Join(',', Arguments.AsEnumerable())})";
+
+    /// <summary>
+    /// The <see cref="NeutralText"/> representation of the instruction.
+    /// </summary>
+    /// <value>A <see cref="NeutralText"/> instance that represents the instruction in Logix neutral text format.</value>
+    public NeutralText Text => new($"{Key}{Signature}");
+    
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+    {
+        if (ReferenceEquals(this, obj)) return true;
+
+        return obj switch
+        {
+            Instruction other => Key.IsEquivalent(other.Key),
+            string key => Key.IsEquivalent(key),
+            _ => false
+        };
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode() => Key.GetHashCode();
+    
+    /// <summary>
+    /// Determines the the provided <see cref="Instruction"/> has the same.
+    /// </summary>
+    /// <param name="other"></param>
+    /// <returns></returns>
+    public bool IsEquivalent(Instruction? other) => other is not null && Text.Equals(other.Text);
+
+    /// <summary>
+    /// Creates a <see cref="Instruction"/> that represents the current instruction with the provided
+    /// argument values.
+    /// </summary>
+    /// <param name="arguments">The collection of arguments that are provided to the instruction signature.</param>
+    /// <returns>A new <see cref="Instruction"/> complete with the provided <see cref="Argument"/> values.</returns>
+    public Instruction Of(params Argument[] arguments) => new(Key, arguments);
+
+    /// <summary>
+    /// Parses the provided string neutral text into a <see cref="Instruction"/> instance.
+    /// </summary>
+    /// <param name="text">The neutral text to parse.</param>
+    /// <returns>A <see cref="Instruction"/> object representing the parsed text.</returns>
+    /// <exception cref="ArgumentException"><c>text</c> is null or empty.</exception>
+    public static Instruction Parse(string text)
+    {
+        if (string.IsNullOrEmpty(text))
+            throw new ArgumentException("Instruction text cannot be null or empty.", nameof(text));
+
+        if (!Regex.IsMatch(text, Pattern))
+            throw new FormatException("Instruction text must be in the format of 'KEY(ARGUMENTS)'.");
+
+        var key = text[..text.IndexOf('(')];
+        var signature = Regex.Match(text, SignaturePattern).Value[1..^1];
+        var arguments = Regex.Split(signature, ",(?![^[]*])").Select(Argument.Parse).ToArray();
+        
+        return new Instruction(key, arguments);
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => Key;
+
+    /// <summary>
+    /// Returns a collection of all known or defined <see cref="Instruction"/> instances.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="IEnumerable{T}"/> containing all known <see cref="Instruction"/> instances with no arguments.
+    /// </returns>
+    public static IEnumerable<string> Keys() => _known.Value.Keys.AsEnumerable();
+
+    /// <summary>
+    /// Returns a collection of all known or defined <see cref="Instruction"/> instances.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="IEnumerable{T}"/> containing all known <see cref="Instruction"/> instances with no arguments.
+    /// </returns>
+    public static IEnumerable<Instruction> Known() => _known.Value.Values.AsEnumerable();
+
+    /// <summary>
+    /// Implicitly converts the <see cref="Instruction"/> instance to a <see cref="string"/> value.
+    /// </summary>
+    /// <param name="instruction">The instruction to convert.</param>
+    /// <returns>A <see cref="string"/> representing the instrcution key.</returns>
+    public static implicit operator string(Instruction instruction) => instruction.Key;
 
     /// <summary>
-    /// Indicates whether the instruction is destructive, meaning the instruction assigns value to it's operands.
+    /// Explicitly converts the <see cref="string"/> value to an <see cref="Instruction"/> instance.
     /// </summary>
-    /// <value><c>true</c> if the instruction is destructive; Otherwise, <c>false</c>.</value>
-    public bool Destructive { get; }
+    /// <param name="key">The string key of the instrution.</param>
+    /// <returns></returns>
+    public static implicit operator Instruction(string key) => new(key);
+
+    /// <summary>
+    /// Determines the equality of two <see cref="Instruction"/> instances.
+    /// </summary>
+    /// <param name="left">The left <see cref="Instruction"/> to compare.</param>
+    /// <param name="right">The right <see cref="Instruction"/> to compare.</param>
+    /// <returns><c>true</c> if the values are equal; Otherwise, <c>false</c>.</returns>
+    public static bool operator ==(Instruction? left, Instruction? right) => Equals(left, right);
+
+    /// <summary>
+    /// Determines the equality of two <see cref="Instruction"/> instances.
+    /// </summary>
+    /// <param name="left">The left <see cref="Instruction"/> to compare.</param>
+    /// <param name="right">The right <see cref="Instruction"/> to compare.</param>
+    /// <returns><c>true</c> if the values are not equal; Otherwise, <c>false</c>.</returns>
+    public static bool operator !=(Instruction? left, Instruction? right) => !Equals(left, right);
+
+    #region Instructions
 
     /// <summary>
     /// Gets the <c>ABL</c> instruction definition instance.
@@ -411,12 +551,12 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>GEQ</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction GEQ = new(nameof(GEQ), false);
+    public static readonly Instruction GEQ = new(nameof(GEQ));
 
     /// <summary>
     /// Gets the <c>GRT</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction GRT = new(nameof(GRT), false);
+    public static readonly Instruction GRT = new(nameof(GRT));
 
     /// <summary>
     /// Gets the <c>GSV</c> instruction definition instance.
@@ -461,12 +601,12 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>LEQ</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction LEQ = new(nameof(LEQ), false);
+    public static readonly Instruction LEQ = new(nameof(LEQ));
 
     /// <summary>
     /// Gets the <c>LES</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction LES = new(nameof(LES), false);
+    public static readonly Instruction LES = new(nameof(LES));
 
     /// <summary>
     /// Gets the <c>LFL</c> instruction definition instance.
@@ -481,7 +621,7 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>LIM</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction LIM = new(nameof(LIM), false);
+    public static readonly Instruction LIM = new(nameof(LIM));
 
     /// <summary>
     /// Gets the <c>LN</c> instruction definition instance.
@@ -661,7 +801,7 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>MEQ</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction MEQ = new(nameof(MEQ), false);
+    public static readonly Instruction MEQ = new(nameof(MEQ));
 
     /// <summary>
     /// Gets the <c>MGS</c> instruction definition instance.
@@ -756,7 +896,7 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>NEQ</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction NEQ = new(nameof(NEQ), false);
+    public static readonly Instruction NEQ = new(nameof(NEQ));
 
     /// <summary>
     /// Gets the <c>NOP</c> instruction definition instance.
@@ -1046,12 +1186,12 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// <summary>
     /// Gets the <c>XIC</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction XIC = new(nameof(XIC), false);
+    public static readonly Instruction XIC = new(nameof(XIC));
 
     /// <summary>
     /// Gets the <c>XIO</c> instruction definition instance.
     /// </summary>
-    public static readonly Instruction XIO = new(nameof(XIO), false);
+    public static readonly Instruction XIO = new(nameof(XIO));
 
     /// <summary>
     /// Gets the <c>XOR</c> instruction definition instance.
@@ -1063,21 +1203,34 @@ private Instruction(string key, bool destructive, params Argument[] arguments) :
     /// </summary>
     public static readonly Instruction XPY = new(nameof(XPY));
 
+    #endregion
+    
     /// <summary>
-    /// Creates a <see cref="Instruction"/> that represents the current instruction with the provided
-    /// argument values.
+    /// List of known instrcution keys to used to determine if a given instruction is destructive.
     /// </summary>
-    /// <param name="arguments">The collection of arguments that are provided to the instruction signature.</param>
-    /// <returns>A new <see cref="Instruction"/> complete with the provided <see cref="Argument"/> values.</returns>
-    public Instruction Of(params Argument[] arguments) => new(Name, Destructive, arguments);
+    private static List<string> ConditionalKeys() => new()
+    {
+        nameof(CMP), nameof(EQU), nameof(GEQ), nameof(GRT),nameof(LEQ), nameof(LES),
+        nameof(LIM), nameof(MEQ), nameof(NEQ), nameof(XIC),nameof(XIO)
+    };
 
     /// <summary>
-    /// Returns the current <c>Instruction</c> as a <see cref="NeutralText"/> value using the current key and arguments.
+    /// Lazy list of all known instructions.
     /// </summary>
-    /// <returns>A <see cref="NeutralText"/> value for the current instruction instance.</returns>
-    public NeutralText ToText()
+    private static Lazy<Dictionary<string, Instruction>> _known =>
+        new(() => GetInstructionFields().ToDictionary(i => i.Key, StringComparer.OrdinalIgnoreCase),
+            LazyThreadSafetyMode.ExecutionAndPublication);
+
+    /// <summary>
+    /// Returns all defined instructions members for the provided type.
+    /// </summary>
+    private static IEnumerable<Instruction> GetInstructionFields()
     {
-        var signamture = string.Join(',', Arguments.AsEnumerable());
-        return new NeutralText($"{Name}({signamture})");
+        var type = typeof(Instruction);
+
+        return type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
+            .Where(f => type.IsAssignableFrom(f.FieldType))
+            .Select(f => (Instruction) f.GetValue(null))
+            .ToList();
     }
 }
\ No newline at end of file
diff --git a/src/L5Sharp/Common/NeutralText.cs b/src/L5Sharp/Common/NeutralText.cs
index 43ee98e6..0c908667 100644
--- a/src/L5Sharp/Common/NeutralText.cs
+++ b/src/L5Sharp/Common/NeutralText.cs
@@ -8,54 +8,23 @@
 namespace L5Sharp.Common;
 
 /// <summary>
-/// A wrapper class around the textual representation of the ladder logic notation called neutral text. 
+/// A thin wrapper around the textual representation of logic notation called neutral text. This could represent a
+/// single instruction signature, a rung of logic (combination of instructions), or a line of structured text. The
+/// purpose of this class is to provide a way to parse the text into strongly typed objects that are easier to work with. 
 /// </summary>
 /// <remarks>
 /// Neutral text can represent a single instruction or a full rung (collection of instructions).
-/// Each instruction contains sets of tag names and values known as operands.
+/// Each instruction contains sets of tag names and values known as arguments or operands.
 /// This class provides functions for extracting the textual information into strongly type classes that are easier
 /// to work with.
 /// </remarks>
 /// <seealso cref="Instruction"/>
 /// <seealso cref="TagName"/>
+/// <seealso cref="Keyword"/>
 public sealed class NeutralText
 {
     private readonly string _text;
-
-    /// <summary>
-    /// The regex pattern for Logix tag names without starting and ending anchors.
-    /// This pattern also includes a negative lookahead for removing text prior to parenthesis (i.e. instruction keys)
-    /// Use this pattern for tag names within text, such as longer
-    /// </summary>
-    private const string TagNamePattern =
-        @"(?!\w*\()[A-Za-z_][\w+:]{1,39}(?:(?:\[\d+\]|\[\d+,\d+\]|\[\d+,\d+,\d+\])?(?:\.[A-Za-z_]\w{1,39})?)+(?:\.[0-9][0-9]?)?";
-
-    /// <summary>
-    /// Pattern for identifying any instruction and the contents of it's signature. This expression should
-    /// capture everything enclosed or between the instruction parentheses. This includes nested parenthesis.
-    /// This works on the assumption that the text has balances opening/closing parentheses.
-    /// </summary>
-    private const string InstructionPattern = @"[A-Za-z_]\w{1,39}\((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))\)";
-
-    /// <summary>
-    /// Pattern finds all text prior to opening parentheses, which is the instruction name or key that identifies
-    /// the instruction. 
-    /// </summary>
-    private const string InstructionKeysPattern = @"[A-Za-z_]\w{1,39}(?=\()";
-
-    /// <summary>
-    /// Pattern finds all text prior to opening parentheses, which is the instruction name or key that identifies
-    /// the instruction. 
-    /// </summary>
-    private const string SignaturePattern = @"\((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))\)";
-
-    private const string OperandsPattern =
-        @"(?<=[A-Za-z_]\w{1,39}\()(?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))(?=\))";
-
-    private const string KeyOperandGroupPattern =
-        @"([A-Za-z_]\w{1,39})\(((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!)))\)";
-
-
+    
     /// <summary>
     /// Creates a new <see cref="NeutralText"/> object with the provided text input.
     /// </summary>
@@ -73,40 +42,18 @@ public NeutralText(string text)
     /// <value><c>true</c> if the text has balanced brackets and parentheses; otherwise, <c>false</c>.</value>
     public bool IsBalanced => TextIsBalanced(_text, '[', ']') && TextIsBalanced(_text, '(', ')');
 
-    /// <summary>
-    /// Indicates whether the current neutral text value is a single instruction, as opposed to a rung/line
-    /// of multiple instructions.
-    /// </summary>
-    /// <value><c>true</c> if the text represents a single instruction. <c>false</c> if not, meaning the text is a
-    /// collection of multiple instruction patterns.</value>
-    public bool IsSingle => Regex.IsMatch(_text, $"^{InstructionPattern}$");
-
     /// <summary>
     /// Indicates whether the current neutral text value is an empty string.
     /// </summary>
     /// <value><c>true</c> if the text empty; otherwise <c>false</c>.</value>
-    public bool IsEmpty => _text.IsEmpty();
+    public bool IsEmpty => _text.IsEquivalent(string.Empty);
 
     /// <summary>
     /// Represents a new empty instance of the <see cref="NeutralText"/>.
     /// </summary>
     /// <returns>An empty <see cref="NeutralText"/> object.</returns>
-    public static NeutralText Empty => new("");
+    public static NeutralText Empty => new(string.Empty);
 
-    /// <summary>
-    /// Converts a <c>NeutralText</c> object to a <c>string</c> object.
-    /// </summary>
-    /// <param name="text">the <c>NeutralText</c> instance to convert.</param>
-    /// <returns>A <c>string</c> that represents the value of the <c>NeutralText</c>.</returns>
-    public static implicit operator string(NeutralText text) => text._text;
-
-    /// <summary>
-    /// Converts a <c>string</c> object to a <c>NeutralText</c> object.
-    /// </summary>
-    /// <param name="text">the <c>string</c> instance to convert.</param>
-    /// <returns>A <c>NeutralText</c> that represents the value of the <c>string</c>.</returns>
-    public static implicit operator NeutralText(string text) => new(text);
-    
     /// <summary>
     /// Returns a value indicating whether a specified instruction key occurs within this neutral text.
     /// </summary>
@@ -114,26 +61,6 @@ public NeutralText(string text)
     /// <returns><c>true</c> if this text contains the instruction key; otherwise, false..</returns>
     public bool Contains(string value) => _text.Contains(value);
 
-    /// <summary>
-    /// Returns a value indicating whether a specified instruction signature occurs within this neutral text.
-    /// </summary>
-    /// <param name="instruction">The instruction for which to seek.</param>
-    /// <returns><c>true</c> if this text contains the signature pattern defined by <c>instruction</c>.</returns>
-    public bool Contains(Instruction instruction) => Regex.IsMatch(_text, instruction.Signature);
-
-    /// <summary>
-    /// Returns a value indication whether a specified tag name occurs within this neutral text.
-    /// </summary>
-    /// <param name="tagName">The tag name to seek.</param>
-    /// <param name="comparer">The optional equality comparer to user for evaluating tag equivalence.</param>
-    /// <returns><c>true</c> if <c>tagName</c> is contained withing the text and passes the equality check
-    /// specified by <c>comparer</c>.</returns>
-    public bool Contains(TagName tagName, IEqualityComparer<TagName>? comparer = null)
-    {
-        comparer ??= TagNameComparer.Qualified;
-        return Tags().Any(t => comparer.Equals(t, tagName));
-    }
-
     /// <summary>
     /// Runs the provided regex pattern against the neutral text and indicates whether the patterns is matched.
     /// </summary>
@@ -145,184 +72,37 @@ public bool Contains(TagName tagName, IEqualityComparer<TagName>? comparer = nul
     /// Returns a collection of <see cref="Instruction"/> objects that were found in the current neutral text value.
     /// </summary>
     /// <returns>An <see cref="IEnumerable{T}"/> containing <see cref="Instruction"/> objects found in the text.</returns>
-    public IEnumerable<Instruction> Instructions()
-    {
-        var results = new List<Instruction>();
-
-        var keys = Regex.Matches(_text, InstructionKeysPattern).Select(m => m.Value);
-
-        foreach (var key in keys)
-        {
-            if (Instruction.TryFromName(key, out var instruction) && instruction is not null)
-            {
-                results.Add(instruction);
-                continue;
-            }
-
-            //Just assuming an unknown instruction is an AOI and is by default destructive.
-            results.Add(new Instruction(key));
-        }
-
-        return results;
-    }
-
-    /// <summary>
-    /// Gets a collection of instruction keys or names that occur in the current neutral text.
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> containing the names/keys of al found instructions.</returns>
-    public IEnumerable<string> Keys() => Regex.Matches(_text, InstructionKeysPattern).Select(m => m.Value);
-
-    /// <summary>
-    /// Returns a collection of all found operands in the current neutral text value.
-    /// </summary>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the instruction(s) operand arguments found in the current text.</returns>
-    /// <remarks>This will return a flat list of operands for all instructions. If you want to get operands
-    /// and corresponding instruction key, use the <see cref="OperandsByKey()"/> methods, which will return found
-    /// operands along with the corresponding instruction.
-    /// </remarks>
-    /// <seealso cref="OperandsByKey()"/>
-    public IEnumerable<string> Operands() =>
-        Regex.Matches(_text, OperandsPattern).SelectMany(m => m.Value.Split(","));
-
-    /// <summary>
-    /// Returns a collection of <see cref="KeyValuePair"/> with the key being the instruction and corresponding
-    /// operand arguments as the value.
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair"/> objects containing instruction key
-    /// and corresponding operands values.</returns>
-    public IEnumerable<KeyValuePair<string, IEnumerable<string>>> OperandsByKey() =>
-        Regex.Matches(_text, KeyOperandGroupPattern).Select(m =>
-            new KeyValuePair<string, IEnumerable<string>>(m.Groups[1].Value, m.Groups[2].Value.Split(",")));
-
-    /// <summary>
-    /// Returns a collection of <see cref="KeyValuePair"/> with the key being the instruction and corresponding
-    /// operand arguments as the value.
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair"/> objects containing instruction key
-    /// and corresponding operands values.</returns>
-    public IEnumerable<KeyValuePair<string, IEnumerable<string>>> OperandsByKey(string key) =>
-        Regex.Matches(_text, @$"(?<={key}\()(?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))(?=\))")
-            .Select(m => new KeyValuePair<string, IEnumerable<string>>(key, m.Value.Split(',')));
-
-    /// <summary>
-    /// Returns a collection of <see cref="KeyValuePair"/> with the key being the instruction and corresponding
-    /// operand arguments as the value.
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair"/> objects containing instruction key
-    /// and corresponding operands values.</returns>
-    public IEnumerable<KeyValuePair<Instruction, IEnumerable<string>>> OperandsByKey(Instruction instruction) =>
-        Regex.Matches(_text, @$"(?<={instruction.Name}\()(?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))(?=\))")
-            .Select(m => new KeyValuePair<Instruction, IEnumerable<string>>(instruction, m.Value.Split(',')));
-
-    /// <summary>
-    /// Returns a collection of <see cref="KeyValuePair{TKey,TValue}"/> with the key being a tag found in the
-    /// neutral text instance, and the value being it's corresponding instruction sub text where it is referenced
-    /// within the neutral text instance. 
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair"/> objects containing
-    /// <see cref="TagName"/> and <see cref="NeutralText"/> pairs.</returns>
-    public IEnumerable<KeyValuePair<TagName, NeutralText>> References()
-    {
-        return Regex.Matches(_text, KeyOperandGroupPattern).SelectMany(m =>
-        {
-            var tags = Regex.Matches(m.Value, TagNamePattern).Select(tn => new TagName(tn.Value));
-            return tags.Select(t => new KeyValuePair<TagName, NeutralText>(t, m.Value));
-        });
-    }
-
-    /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts representing each individual instruction found
-    /// in the current text value.
-    /// </summary>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that represent
-    /// each individual instruction text.</returns>
-    public IEnumerable<NeutralText> Split() =>
-        Regex.Matches(_text, InstructionPattern).Select(m => new NeutralText(m.Value));
-
-    /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts representing a specific single instruction.
-    /// </summary>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that represent
-    /// each individual instruction text.</returns>
-    public IEnumerable<NeutralText> SplitBy(Instruction instruction) =>
-        Regex.Matches(_text, instruction.Signature).Select(m => new NeutralText(m.Value));
+    public IEnumerable<Instruction> Instructions() =>
+        Regex.Matches(_text, Instruction.Pattern).Select(m => Instruction.Parse(m.Value));
 
     /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts representing a set of specific instructions.
-    /// </summary>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that represent
-    /// each individual instruction text.</returns>
-    public IEnumerable<NeutralText> SplitBy(IEnumerable<Instruction> instructions) =>
-        instructions.SelectMany(i => Regex.Matches(_text, i.Signature).Select(m => new NeutralText(m.Value)));
-
-    /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts matching a specific regex pattern.  
+    /// Returns a collection of <see cref="Instruction"/> objects that were found in the current neutral text value.
     /// </summary>
-    /// <param name="pattern">The regular expression for which to match against.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that match the
-    /// specified pattern.</returns>
-    public IEnumerable<NeutralText> SplitBy(string pattern) =>
-        Regex.Matches(_text, $"{pattern}").Select(m => new NeutralText(m.Value));
+    /// <returns>An <see cref="IEnumerable{T}"/> containing <see cref="Instruction"/> objects found in the text.</returns>
+    public IEnumerable<Instruction> Instructions(Instruction instruction) =>
+        Regex.Matches(_text, Instruction.Pattern).Select(m => Instruction.Parse(m.Value)).Where(i => i == instruction);
 
     /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts matching a set of regex patterns.  
+    /// Gets a collection of keywords found in the current neutral text.
     /// </summary>
-    /// <param name="patterns">A collection of regular expressions for which to match against.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that match the
-    /// specified patterns.</returns>
-    public IEnumerable<NeutralText> SplitBy(IEnumerable<string> patterns) =>
-        patterns.SelectMany(p => Regex.Matches(_text, $"{p}").Select(m => new NeutralText(m.Value)));
-
-    /// <summary>
-    /// Splits the current neutral text into a collection of sub-texts having a specific instruction key.
-    /// </summary>
-    /// <param name="key">The instruction key to match against.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the <see cref="NeutralText"/> objects that represent
-    /// each individual instruction text.</returns>
-    public IEnumerable<NeutralText> SplitByKey(string key) =>
-        Regex.Matches(_text, $"{key}{SignaturePattern}").Select(m => new NeutralText(m.Value));
-    
+    /// <returns>A <see cref="IEnumerable{T}"/> containing <see cref="Keyword"/> values found.</returns>
+    public IEnumerable<Keyword> Keywords() => Keyword.All().Where(k => _text.Contains(k.Value));
 
     /// <summary>
     /// Gets a collection of tag names found in the current neutral text.
     /// </summary>
     /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="TagName"/> values that were in from the current text.</returns>
-    /// <seealso cref="TagsIn(L5Sharp.Enums.Instruction)"/>
-    /// <seealso cref="TagsIn(System.String)"/>
-    public IEnumerable<TagName> Tags() => Regex.Matches(_text, TagNamePattern).Select(m => new TagName(m.Value));
-
-    /*/// <summary>
-    /// Returns a collection of <see cref="KeyValuePair"/> with the key being the instruction and corresponding
-    /// operand arguments as the value.
-    /// </summary>
-    /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair"/> objects containing instruction key
-    /// and corresponding operands values.</returns>
-    public IEnumerable<KeyValuePair<string, IEnumerable<TagName>>> TagsByKey() =>
-        Regex.Matches(_text, KeyOperandGroupPattern).Select(m =>
-            new KeyValuePair<string, IEnumerable<string>>(m.Groups[1].Value, m.Groups[2].Value.Split(",")));*/
-
+    /// <seealso cref="TagsIn(Instruction)"/>
+    public IEnumerable<TagName> Tags() =>
+        Instructions().SelectMany(i => i.Arguments).Where(a => a.IsTag).Select(a => (TagName) a);
 
     /// <summary>
     /// Gets a collection of tag names found in the current neutral text that are operands or arguments to a specific instruction.
     /// </summary>
     /// <param name="instruction">The instruction for which to find tags as arguments to.</param>
     /// <returns>A <see cref="IEnumerable{T}"/> containing tag names found in the specified instruction.</returns>
-    /// <seealso cref="TagsIn(System.String)"/>
     public IEnumerable<TagName> TagsIn(Instruction instruction) =>
-        Regex.Matches(_text, instruction.Signature)
-            .SelectMany(m => Regex.Matches(m.Value, TagNamePattern))
-            .Select(m => new TagName(m.Value));
-
-    /// <summary>
-    /// Gets all tags found in the current neutral text that are arguments to a specific instruction key value. 
-    /// </summary>
-    /// <param name="key">The name of the instruction for which to get tags.</param>
-    /// <returns>A <see cref="IEnumerable{T}"/> containing tag names found in the specified instruction.</returns>
-    /// <seealso cref="TagsIn(L5Sharp.Enums.Instruction)"/>
-    public IEnumerable<TagName> TagsIn(string key) =>
-        Regex.Matches(_text, $"{key}{SignaturePattern}")
-            .SelectMany(m => Regex.Matches(m.Value, TagNamePattern))
-            .Select(m => new TagName(m.Value));
+        Instructions(instruction).SelectMany(i => i.Arguments).Where(a => a.IsTag).Select(a => (TagName) a);
 
     /// <inheritdoc />
     public override string ToString() => _text;
@@ -331,11 +111,11 @@ public IEnumerable<TagName> TagsIn(string key) =>
     public override bool Equals(object? obj)
     {
         if (ReferenceEquals(this, obj)) return true;
-        
+
         return obj switch
         {
-            NeutralText other => string.Equals(_text, other._text, StringComparison.OrdinalIgnoreCase),
-            string other => string.Equals(_text, other, StringComparison.OrdinalIgnoreCase),
+            NeutralText other => _text.IsEquivalent(other._text),
+            string other => _text.IsEquivalent(other),
             _ => false
         };
     }
@@ -359,6 +139,20 @@ public override bool Equals(object? obj)
     /// <returns>true if the provided objects are not equal; otherwise, false.</returns>
     public static bool operator !=(NeutralText? left, NeutralText? right) => !Equals(left, right);
 
+    /// <summary>
+    /// Converts a <c>NeutralText</c> object to a <c>string</c> object.
+    /// </summary>
+    /// <param name="text">the <c>NeutralText</c> instance to convert.</param>
+    /// <returns>A <c>string</c> that represents the value of the <c>NeutralText</c>.</returns>
+    public static implicit operator string(NeutralText text) => text._text;
+
+    /// <summary>
+    /// Converts a <c>string</c> object to a <c>NeutralText</c> object.
+    /// </summary>
+    /// <param name="text">the <c>string</c> instance to convert.</param>
+    /// <returns>A <c>NeutralText</c> that represents the value of the <c>string</c>.</returns>
+    public static implicit operator NeutralText(string text) => new(text);
+
     private bool TextIsBalanced(string value, char opening, char closing)
     {
         var characters = new Stack<char>();
@@ -376,43 +170,4 @@ private bool TextIsBalanced(string value, char opening, char closing)
 
         return characters.Count == 0;
     }
-}
-
-/// <summary>
-/// A class containing extensions for the <see cref="NeutralText"/> class.
-/// </summary>
-public static class NeutralTextExtensions
-{
-    /// <summary>
-    /// Returns all referenced tag names and their corresponding list of <see cref="NeutralText"/> logic references in
-    /// the current collection of <see cref="NeutralText"/>.
-    /// </summary>
-    /// <param name="text">A collection of <see cref="NeutralText"/> rung logic.</param>
-    /// <returns>A <see cref="Dictionary{TKey,TValue}"/> where each tag name is a key and it's corresponding value is
-    /// a <see cref="List{T}"/> containing all the logic referencing the tag found in the file.</returns>
-    /// <remarks>
-    /// This is useful for performing quick lookup of logic references by tag name.
-    /// </remarks>
-    public static Dictionary<TagName, List<NeutralText>> ToTagLookup(this IEnumerable<NeutralText> text)
-    {
-        var results = new Dictionary<TagName, List<NeutralText>>();
-
-        foreach (var line in text)
-        {
-            var tags = line.Tags();
-
-            foreach (var tag in tags)
-            {
-                if (!results.ContainsKey(tag))
-                {
-                    results.Add(tag, new List<NeutralText> { line });
-                    continue;
-                }
-
-                results[tag].Add(line);
-            }
-        }
-
-        return results;
-    }
 }
\ No newline at end of file
diff --git a/src/L5Sharp/Common/TagName.cs b/src/L5Sharp/Common/TagName.cs
index 60a2c6d8..82a6e411 100644
--- a/src/L5Sharp/Common/TagName.cs
+++ b/src/L5Sharp/Common/TagName.cs
@@ -3,7 +3,6 @@
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
-using L5Sharp.Enums;
 using L5Sharp.Utilities;
 
 namespace L5Sharp.Common;
@@ -23,12 +22,12 @@ public sealed class TagName : IComparable<TagName>, IEquatable<TagName>
     private const char ArrayOpenSeparator = '[';
     private const char ArrayCloseSeparator = ']';
 
-    /// <summary>
+    /*/// <summary>
     /// A regex pattern for a Logix tag name with starting and ending anchors.
     /// Use this pattern to match a string and ensure it is only a tag name an nothing else.
     /// </summary>
     private const string TagNamePattern =
-        @"^[A-Za-z_][\w+:]{1,39}(?:(?:\[\d+\]|\[\d+,\d+\]|\[\d+,\d+,\d+\])?(?:\.[A-Za-z_]\w{1,39})?)+(?:\.[0-9][0-9]?)?$";
+        @"^[A-Za-z_][\w+:]{1,39}(?:(?:\[\d+\]|\[\d+,\d+\]|\[\d+,\d+,\d+\])?(?:\.[A-Za-z_]\w{1,39})?)+(?:\.[0-9][0-9]?)?$";*/
 
     /// <summary>
     /// Creates a new <see cref="TagName"/> object with the provided string tag name.
@@ -117,7 +116,14 @@ public TagName(string tagName)
     /// <summary>
     /// Gets a value indicating whether the current <see cref="TagName"/> is a valid representation of a tag name.
     /// </summary>
-    public bool IsQualified => Regex.IsMatch(_tagName, TagNamePattern);
+    public bool IsQualified => IsQualifiedTagName(_tagName);
+
+    /// <summary>
+    /// Determines if the provided string value is a valid tag name.
+    /// </summary>
+    /// <param name="value">The <see cref="string"/> to test.</param>
+    /// <returns><c>true</c> if the value is a valid qualified tag name; Otherwise, <c>false</c>.</returns>
+    public static bool IsTag(string value) => IsQualifiedTagName(value);
 
     /// <summary>
     /// Gets the static empty <see cref="TagName"/> value.
@@ -268,16 +274,16 @@ public override bool Equals(object? obj)
     /// </summary>
     private static string GetRoot(string tagName)
     {
-        if (tagName.IsEmpty() || tagName.StartsWith(Keyword.Period)) return string.Empty;
-        if (tagName.StartsWith(Keyword.LeftBracket))
+        if (tagName.IsEmpty() || tagName.StartsWith(MemberSeparator)) return string.Empty;
+        if (tagName.StartsWith(ArrayOpenSeparator))
         {
-            return tagName[..tagName.IndexOf(Keyword.RightBracket)];
+            return tagName[..tagName.IndexOf(ArrayCloseSeparator)];
         }
 
-        var index = tagName.IndexOfAny(new[] { MemberSeparator, ArrayOpenSeparator });
+        var index = tagName.IndexOfAny(new[] {MemberSeparator, ArrayOpenSeparator});
         return index > 0 ? tagName[..index] : tagName;
     }
-    
+
     /// <summary>
     /// Gets the last member of the tag name, or the portion of the string from the end to the last member separator.
     /// We are no longer using regex to make this as efficient as possible since there could realistically be millions
@@ -285,63 +291,25 @@ private static string GetRoot(string tagName)
     /// </summary>
     private static string GetMember(string tagName)
     {
-        var index = tagName.LastIndexOfAny(new[] { MemberSeparator, ArrayOpenSeparator });
+        var index = tagName.LastIndexOfAny(new[] {MemberSeparator, ArrayOpenSeparator});
         var length = tagName.Length - index;
         return index >= 0 ? tagName.Substring(index, length).TrimStart(MemberSeparator) : tagName;
     }
-    
+
     /// <summary>
     /// Gets each member by iterating the tag name string.
     /// We are no longer using regex to make this as efficient as possible since there could realistically be millions
     /// of tag names this can get called on.
     /// </summary>
-    private static IEnumerable<string> GetMembers(string tagName)
-    {
-        var list = new List<string>();
-        var span = new List<char>();
-        var open = false;
-
-        foreach (var character in tagName)
-        {
-            switch (character)
-            {
-                case MemberSeparator:
-                    if (span.Count == 0) continue;
-                    list.Add(new string(span.ToArray()));
-                    span.Clear();
-                    continue;
-                case ArrayOpenSeparator when !open:
-                    open = true;
-                    if (span.Count == 0) break;
-                    list.Add(new string(span.ToArray()));
-                    span.Clear();
-                    break;
-                case ArrayCloseSeparator when open:
-                    open = false;
-                    span.Add(character);
-                    list.Add(new string(span.ToArray()));
-                    span.Clear();
-                    continue;
-            }
-
-            span.Add(character);
-        }
-
-        if (span.Count > 0)
-            list.Add(new string(span.ToArray()));
-
-        return list;
-    }
+    private static IEnumerable<string> GetMembers(string tagName) => 
+        NormalizeDelimiter(tagName).Split(MemberSeparator, StringSplitOptions.RemoveEmptyEntries);
 
     /// <summary>
     /// Gets the zero-based depth or number of members between this member and the root.
     /// We are no longer using regex to make this as efficient as possible since there could realistically be millions
     /// of tag names this can get called on.
     /// </summary>
-    private static int GetDepth(string tagName)
-    {
-        return tagName.Count(c => c is MemberSeparator or ArrayOpenSeparator);
-    }
+    private static int GetDepth(string tagName) => tagName.Count(c => c is MemberSeparator or ArrayOpenSeparator);
 
     /// <summary>
     /// Handles combining an enumerable containing string member names into a single <see cref="TagName"/> value.
@@ -360,6 +328,52 @@ private static string ConcatenateMembers(IEnumerable<string> members)
 
         return builder.ToString();
     }
+
+    private static bool IsQualifiedTagName(string value)
+    {
+        if (value.IsEmpty()) return false;
+
+        var normalized = NormalizeDelimiter(value);
+        var members = normalized.Split(MemberSeparator).ToList();
+
+        for (var i = 0; i < members.Count; i++)
+        {
+            switch (i)
+            {
+                case 0 when !IsValidRoot(members[i]):
+                case > 0 when members[i].StartsWith(ArrayOpenSeparator) && !IsValidIndex(members[i]):
+                case > 0 when char.IsLetter(members[i][0]) && !IsValidMember(members[i]):
+                    return false;
+            }
+
+            if (i == members.Count - 1 && char.IsDigit(members[i][0]) && !IsValidBit(members[i])) return false;
+        }
+
+        return true;
+
+        bool IsValidRoot(string member) => Regex.IsMatch(member, @"^[A-Za-a_][\w:]{0,39}$");
+
+        bool IsValidMember(string member) => Regex.IsMatch(member, @"^[A-Za-a_][\w]{0,39}$");
+
+        bool IsValidIndex(string member) => Regex.IsMatch(member, @"^\[[0-9]+(?:\,[0-9]+)?(?:\,[0-9]+)?\]$");
+
+        bool IsValidBit(string member) =>
+            member.All(char.IsDigit) && int.TryParse(member, out var bit) && bit is >= 0 and <= 63;
+    }
+
+    private static string NormalizeDelimiter(string value)
+    {
+        var builder = new StringBuilder();
+
+        foreach (var character in value)
+        {
+            if (character == ArrayOpenSeparator)
+                builder.Append(MemberSeparator);
+            builder.Append(character);
+        }
+
+        return builder.ToString();
+    }
 }
 
 /// <summary>
diff --git a/src/L5Sharp/Components/AddOnInstruction.cs b/src/L5Sharp/Components/AddOnInstruction.cs
index 887847c9..ffae9232 100644
--- a/src/L5Sharp/Components/AddOnInstruction.cs
+++ b/src/L5Sharp/Components/AddOnInstruction.cs
@@ -224,10 +224,10 @@ public LogixContainer<Routine> Routines
     #region Extensions
 
     /// <summary>
-    /// Returns the AOI instruction logic with the parameters tag names replaced with the operand tag names of the
-    /// provided neutral text signature.
+    /// Returns the AOI instruction logic with the parameters tag names replaced with the argument tag names of the
+    /// provided instruction instance.
     /// </summary>
-    /// <param name="text">The text signature of the instruction arguments.</param>
+    /// <param name="instruction">The instruction instance for which to generate the underlying logic.</param>
     /// <returns>
     /// A <see cref="IEnumerable{T}"/> containing <see cref="NeutralText"/> representing all the instruction's
     /// logic, with each instruction parameter tag name replaced with the arguments from the provided text.
@@ -237,10 +237,10 @@ public LogixContainer<Routine> Routines
     /// reason or evaluate it as if it was written in line. Currently only supports <see cref="Rung"/>
     /// content or code type.
     /// </remarks>
-    public IEnumerable<NeutralText> Logic(NeutralText text)
+    public IEnumerable<NeutralText> Logic(Instruction instruction)
     {
-        if (text is null)
-            throw new ArgumentNullException(nameof(text));
+        if (instruction is null)
+            throw new ArgumentNullException(nameof(instruction));
 
         // All instructions primary logic is contained in the routine named 'Logic'
         var logic = Routines.FirstOrDefault(r => r.Name == "Logic");
@@ -249,19 +249,19 @@ public IEnumerable<NeutralText> Logic(NeutralText text)
         if (rungs is null) return Enumerable.Empty<NeutralText>();
 
         //Skip first operand as it is always the AOI tag, which does not have corresponding parameter within the logic.
-        var arguments = text.Operands().Select(o => o.ToString()).Skip(1).ToList();
+        var arguments = instruction.Arguments.Select(a => a.ToString()).Skip(1).ToList();
 
         //Only required parameters are part of the instruction signature
         var parameters = Parameters.Where(p => p.Required is true).Select(p => p.Name).ToList();
 
-        //Deserialize a mapping of the provided text operand arguments to instruction parameter names.
+        //Generate a mapping of the provided instructions arguments to instruction parameters.
         var mapping = arguments.Zip(parameters, (a, p) => new {Argument = a, Parameter = p}).ToList();
 
         //Replace all parameter names with argument names in the instruction logic text, and return the results.
         return rungs.Select(r => r.Text)
             .Select(t => mapping.Aggregate(t, (current, pair) =>
             {
-                if (!pair.Argument.IsTagName()) return current;
+                if (!pair.Argument.IsTag()) return current;
                 var replace = $@"(?<=[^.]){pair.Parameter}\b";
                 return Regex.Replace(current, replace, pair.Argument.ToString());
             }))
diff --git a/src/L5Sharp/Elements/DiagramBlock.cs b/src/L5Sharp/Elements/DiagramBlock.cs
index d8e98ae3..a03b1a7d 100644
--- a/src/L5Sharp/Elements/DiagramBlock.cs
+++ b/src/L5Sharp/Elements/DiagramBlock.cs
@@ -91,7 +91,7 @@ public bool HideDesc
     /// <inheritdoc />
     public override IEnumerable<LogixReference> References()
     {
-        if (Operand is not null && Operand.IsTagName())
+        if (Operand is not null && Operand.IsTag())
             yield return new LogixReference(Element, Operand, L5XName.Tag);
         
         if (Type is not null)
diff --git a/src/L5Sharp/Elements/DiagramInstruction.cs b/src/L5Sharp/Elements/DiagramInstruction.cs
index 4abb8ada..e7778ec1 100644
--- a/src/L5Sharp/Elements/DiagramInstruction.cs
+++ b/src/L5Sharp/Elements/DiagramInstruction.cs
@@ -98,14 +98,14 @@ public IEnumerable<KeyValuePair<string, string>> Parameters
     /// <inheritdoc />
     public override IEnumerable<LogixReference> References()
     {
-        if (Operand is not null && Operand.IsTagName())
+        if (Operand is not null && Operand.IsTag())
             yield return new LogixReference(Element, Operand, L5XName.Tag);
         
         if (Name is not null)
             yield return new LogixReference(Element, Name, L5XName.AddOnInstructionDefinition);
         
         foreach (var parameter in Parameters)
-            if (parameter.Value.IsTagName())
+            if (parameter.Value.IsTag())
                 yield return new LogixReference(Element, parameter.Value, L5XName.Tag);
     }
 }
\ No newline at end of file
diff --git a/src/L5Sharp/Elements/DiagramReference.cs b/src/L5Sharp/Elements/DiagramReference.cs
index 1bf0fe8c..4914a72c 100644
--- a/src/L5Sharp/Elements/DiagramReference.cs
+++ b/src/L5Sharp/Elements/DiagramReference.cs
@@ -66,7 +66,7 @@ public bool HideDesc
     /// <inheritdoc />
     public override IEnumerable<LogixReference> References()
     {
-        if (Operand is not null && Operand.IsTagName())
+        if (Operand is not null && Operand.IsTag())
         {
             yield return new LogixReference(Element, Operand, L5XName.Tag);
         }
diff --git a/src/L5Sharp/Elements/DiagramRoutine.cs b/src/L5Sharp/Elements/DiagramRoutine.cs
index bf425166..bea00d38 100644
--- a/src/L5Sharp/Elements/DiagramRoutine.cs
+++ b/src/L5Sharp/Elements/DiagramRoutine.cs
@@ -78,11 +78,11 @@ public override IEnumerable<LogixReference> References()
             yield return new LogixReference(Element, Routine, L5XName.Routine);
         
         foreach (var parameter in In)
-            if (parameter.IsTagName())
+            if (parameter.IsTag())
                 yield return new LogixReference(Element, parameter, L5XName.Tag);
         
         foreach (var parameter in Ret)
-            if (parameter.IsTagName())
+            if (parameter.IsTag())
                 yield return new LogixReference(Element, parameter, L5XName.Tag);
     }
 }
\ No newline at end of file
diff --git a/src/L5Sharp/Elements/Line.cs b/src/L5Sharp/Elements/Line.cs
index a1395e62..f06938ab 100644
--- a/src/L5Sharp/Elements/Line.cs
+++ b/src/L5Sharp/Elements/Line.cs
@@ -53,7 +53,7 @@ public override IEnumerable<LogixReference> References()
             .Select(name => new LogixReference(Element, name, L5XName.Tag)));
 
         references.AddRange(Text.Instructions()
-            .Select(name => new LogixReference(Element, name, L5XName.AddOnInstructionDefinition)));
+            .Select(instruction => new LogixReference(Element, instruction.Key, L5XName.AddOnInstructionDefinition)));
 
         //todo routines? Have to look for JSR and SBR, RET
         //todo modules? Have to look for tag names with ':'
diff --git a/src/L5Sharp/Elements/Rung.cs b/src/L5Sharp/Elements/Rung.cs
index 51fe3c52..4f8a26ea 100644
--- a/src/L5Sharp/Elements/Rung.cs
+++ b/src/L5Sharp/Elements/Rung.cs
@@ -85,7 +85,7 @@ public override IEnumerable<LogixReference> References()
             .Select(name => new LogixReference(Element, name, L5XName.Tag)));
 
         references.AddRange(Text.Instructions()
-            .Select(name => new LogixReference(Element, name, L5XName.AddOnInstructionDefinition)));
+            .Select(name => new LogixReference(Element, name.Key, L5XName.AddOnInstructionDefinition)));
 
         //todo routines? Have to look for JSR and SBR, RET
         //todo modules? Have to look for tag names with ':'
@@ -133,7 +133,7 @@ public IEnumerable<NeutralText> Flatten()
         var code = new List<NeutralText>();
 
         var references = L5X.Instructions
-            .Select(i => new {Instruction = i, Instances = Text.SplitByKey(i.Name)})
+            .Select(i => new {Instruction = i, Instances = Text.Instructions(i.Name)})
             .ToList();
 
         foreach (var reference in references.Where(r => r.Instances.Any()))
@@ -175,23 +175,22 @@ public static IEnumerable<NeutralText> Flatten(this IEnumerable<Rung> rungs)
         if (content is null)
             throw new InvalidOperationException("Can not flatten rungs that are not attached to a L5X content file.");
 
-        var aoiLookup = content.Instructions.ToDictionary(k => k.Name, v => v);
+        var lookup = content.Instructions.ToDictionary(k => k.Name, v => v);
         var text = collection.Select(r => r.Text);
 
         foreach (var line in text)
         {
-            var references = aoiLookup.SelectMany(l => line.SplitByKey(l.Key)).ToList();
+            var instructions = lookup.SelectMany(l => line.Instructions(l.Key)).ToList();
 
-            if (references.Count == 0)
+            if (instructions.Count == 0)
             {
                 code.Add(line);
                 continue;
             }
 
-            foreach (var logic in from reference in references
-                     let key = reference.Instructions().FirstOrDefault()
-                     let instruction = aoiLookup[key]
-                     select instruction.Logic(reference))
+            foreach (var logic in from instruction in instructions
+                     let definition = lookup[instruction.Key]
+                     select definition.Logic(instruction))
             {
                 code.AddRange(logic);
             }
diff --git a/src/L5Sharp/Enums/Keyword.cs b/src/L5Sharp/Enums/Keyword.cs
index ec2633ae..a8b70f55 100644
--- a/src/L5Sharp/Enums/Keyword.cs
+++ b/src/L5Sharp/Enums/Keyword.cs
@@ -22,21 +22,11 @@ private Keyword(string name, string value) : base(name, value)
     /// </summary>
     public static readonly Keyword Case = new(nameof(Case), "case");
     
-    /// <summary>
-    /// Represents the Comma Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword Comma = new(nameof(Comma), ",");
-    
     /// <summary>
     /// Represents the Do Logix <see cref="Keyword"/>.
     /// </summary>
     public static readonly Keyword Do = new(nameof(Do), "do");
     
-    /// <summary>
-    /// Represents the Dot Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword Period = new(nameof(Period), ".");
-    
     /// <summary>
     /// Represents the Else Logix <see cref="Keyword"/>.
     /// </summary>
@@ -92,16 +82,6 @@ private Keyword(string name, string value) : base(name, value)
     /// </summary>
     public static readonly Keyword If = new(nameof(If), "if");
     
-    /// <summary>
-    /// Represents the LeftBracket Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword LeftBracket = new(nameof(LeftBracket), "[");
-    
-    /// <summary>
-    /// Represents the LeftParenthesis Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword LeftParenthesis = new(nameof(LeftParenthesis), ")");
-    
     /// <summary>
     /// Represents the Of Logix <see cref="Keyword"/>.
     /// </summary>
@@ -117,16 +97,6 @@ private Keyword(string name, string value) : base(name, value)
     /// </summary>
     public static readonly Keyword Return = new(nameof(Return), "return");
     
-    /// <summary>
-    /// Represents the RightBracket Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword RightBracket = new(nameof(RightBracket), "]");
-    
-    /// <summary>
-    /// Represents the RightParenthesis Logix <see cref="Keyword"/>.
-    /// </summary>
-    public static readonly Keyword RightParenthesis = new(nameof(RightParenthesis), ")");
-    
     /// <summary>
     /// Represents the Then Logix <see cref="Keyword"/>.
     /// </summary>
diff --git a/src/L5Sharp/Enums/Operator.cs b/src/L5Sharp/Enums/Operator.cs
index 3566d3a7..0bfd90c6 100644
--- a/src/L5Sharp/Enums/Operator.cs
+++ b/src/L5Sharp/Enums/Operator.cs
@@ -8,12 +8,12 @@ public class Operator : LogixEnum<Operator, string>
     private Operator(string name, string value) : base(name, value)
     {
     }
-
+    
     /// <summary>
     /// Represents the Assignment Logix <see cref="Operator"/>.
     /// </summary>
     public static readonly Operator Assignment = new(nameof(Assignment), ":=");
-        
+    
     /// <summary>
     /// Represents the Equal Logix <see cref="Operator"/>.
     /// </summary>
diff --git a/src/L5Sharp/Enums/Radix.cs b/src/L5Sharp/Enums/Radix.cs
index 53259c29..f85f9284 100644
--- a/src/L5Sharp/Enums/Radix.cs
+++ b/src/L5Sharp/Enums/Radix.cs
@@ -133,6 +133,20 @@ public static Radix Infer(string input)
         return FromName(name);
     }
 
+    /// <summary>
+    /// Tries to infer the radix format from a string representing a formatted atomic value.
+    /// </summary>
+    /// <param name="input">The string input for which to infer the radix format.</param>
+    /// <param name="radix">If parsed successfully, then the <see cref="Radix"/> representing the format of the input;
+    /// Otherwise, <c>null</c>.</param>
+    /// <returns><c>true</c> if a <c>Radix</c> format was inferred from the string input; Otherwise, <c>false</c>.</returns>
+    public static bool TryInfer(string input, out Radix? radix)
+    {
+        var name = Identifiers.FirstOrDefault(i => i.Value.Invoke(input)).Key;
+        radix = name is not null ? FromName(name) : null;
+        return radix is not null;
+    }
+
     /// <summary>
     /// The specifier prefix of the Radix string format.
     /// </summary>
diff --git a/src/L5Sharp/LogixCode.cs b/src/L5Sharp/LogixCode.cs
index a0edd060..8c1143d3 100644
--- a/src/L5Sharp/LogixCode.cs
+++ b/src/L5Sharp/LogixCode.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
-using L5Sharp.Components;
 using L5Sharp.Enums;
 using L5Sharp.Utilities;
 
@@ -108,17 +107,4 @@ public virtual int Number
     /// </summary>
     /// <returns>A <see cref="IEnumerable{T}"/> of <see cref="LogixReference"/> values contained by this code.</returns>
     public abstract IEnumerable<LogixReference> References();
-    
-    /// <summary>
-    /// Gets the parent <see cref="Routine"/> of this <see cref="LogixCode"/> instance if it is attached.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="Routine"/> instance representing the containing routine of the code if found;
-    /// Otherwise, <c>null</c>.
-    /// </returns>
-    public Routine? GetRoutine()
-    {
-        var routine = Element.Ancestors(L5XName.Routine).FirstOrDefault();
-        return routine is not null ? new Routine(routine) : default;
-    }
 }
\ No newline at end of file
diff --git a/src/L5Sharp/LogixReference.cs b/src/L5Sharp/LogixReference.cs
index e44970cf..589b0f7c 100644
--- a/src/L5Sharp/LogixReference.cs
+++ b/src/L5Sharp/LogixReference.cs
@@ -96,10 +96,10 @@ public LogixReference(XElement element, string name, string type)
     public bool IsSame(LogixReference other)
     {
         return ScopeType == other.ScopeType &&
-               ScopeName.IsSame(other.ScopeName) &&
-               RoutineName.IsSame(other.RoutineName) &&
-               ReferenceId.IsSame(other.ReferenceId) &&
-               ReferenceType.IsSame(other.ReferenceType);
+               ScopeName.IsEquivalent(other.ScopeName) &&
+               RoutineName.IsEquivalent(other.RoutineName) &&
+               ReferenceId.IsEquivalent(other.ReferenceId) &&
+               ReferenceType.IsEquivalent(other.ReferenceType);
     }
 
     /// <summary>
diff --git a/src/L5Sharp/Types/Atomic.cs b/src/L5Sharp/Types/Atomic.cs
index 0c10e8ae..d7d57509 100644
--- a/src/L5Sharp/Types/Atomic.cs
+++ b/src/L5Sharp/Types/Atomic.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using L5Sharp.Enums;
 using L5Sharp.Types.Atomics;
+using L5Sharp.Utilities;
 
 namespace L5Sharp.Types;
 
@@ -34,8 +35,8 @@ public static class Atomic
     /// <exception cref="FormatException"><c>value</c> does not have a valid format to be parsed as an atomic type.</exception>
     public static AtomicType Parse(string value)
     {
-        return string.Equals(value, "true", StringComparison.OrdinalIgnoreCase) ? new BOOL(true)
-            : string.Equals(value, "false", StringComparison.OrdinalIgnoreCase) ? new BOOL()
+        return value.IsEquivalent("true") ? new BOOL(true)
+            : value.IsEquivalent("false") ? new BOOL()
             : Radix.Infer(value).Parse(value);
     }
 
@@ -47,8 +48,8 @@ public static AtomicType Parse(string value)
     /// <exception cref="FormatException"><c>value</c> does not have a valid format to be parsed as an atomic type.</exception>
     public static TAtomic Parse<TAtomic>(string value) where TAtomic : AtomicType
     {
-        var atomic = string.Equals(value, "true", StringComparison.OrdinalIgnoreCase) ? new BOOL(true)
-            : string.Equals(value, "false", StringComparison.OrdinalIgnoreCase) ? new BOOL()
+        var atomic = value.IsEquivalent("true") ? new BOOL(true)
+            : value.IsEquivalent("false") ? new BOOL()
             : Radix.Infer(value).Parse(value);
         return (TAtomic)Convert.ChangeType(atomic, typeof(TAtomic));
     }
@@ -69,6 +70,31 @@ public static AtomicType Parse(string name, string value)
         return Atomics[name].Invoke(value);
     }
 
+    /// <summary>
+    /// Attempts to parse the provided string input as an atomic type value with the inferred radix format.
+    /// </summary>
+    /// <param name="value">A string representing an atomic value to parse.</param>
+    /// <param name="atomicType">If the parsed successfully, then the resulting <see cref="AtomicType"/> value;
+    /// Otherwise, <c>null</c>.</param>
+    /// <returns><c>true</c> if the string input was parsed as an atomic type; Otherwise, <c>false</c>.</returns>
+    public static bool TryParse(string value, out AtomicType? atomicType)
+    {
+        if (value.IsEquivalent("true") || value.IsEquivalent("false"))
+        {
+            atomicType = new BOOL(bool.Parse(value));
+            return true;
+        }
+
+        if (Radix.TryInfer(value, out var radix) && radix is not null)
+        {
+            atomicType = radix.Parse(value);
+            return true;
+        }
+        
+        atomicType = default;
+        return false;
+    }
+
     /// <summary>
     /// Returns indication to whether the provided type name is the name of an atomic type.
     /// </summary>
diff --git a/src/L5Sharp/Utilities/L5XExtensions.cs b/src/L5Sharp/Utilities/L5XExtensions.cs
index b2c1d6b7..308baeed 100644
--- a/src/L5Sharp/Utilities/L5XExtensions.cs
+++ b/src/L5Sharp/Utilities/L5XExtensions.cs
@@ -4,7 +4,6 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
-using System.Text.RegularExpressions;
 using System.Xml;
 using System.Xml.Linq;
 using L5Sharp.Common;
@@ -66,8 +65,7 @@ public static string Get(this XElement element, XName name) =>
     /// </summary>
     /// <param name="input">The string input to analyze.</param>
     /// <returns><c>true</c> if the string is a valid tag name string; otherwise, <c>false</c>.</returns>
-    public static bool IsTagName(this string input) => Regex.IsMatch(input,
-        @"^[A-Za-z_][\w+:]{1,39}(?:(?:\[\d+\]|\[\d+,\d+\]|\[\d+,\d+,\d+\])?(?:\.[A-Za-z_]\w{1,39})?)+(?:\.[0-9][0-9]?)?$");
+    public static bool IsTag(this string input) => TagName.IsTag(input);
 
     /// <summary>
     /// Determines if the current string is equal to string.Empty.
@@ -85,7 +83,7 @@ public static bool IsTagName(this string input) => Regex.IsMatch(input,
     /// equality comparer,. Otherwise <c>false</c>.</returns>
     /// <remarks>This is a simplified way of calling the string comparer equals method since it is a little verbose.
     /// This could be used a lot since Logix naming is not case agnostic.</remarks>
-    public static bool IsSame(this string value, string other) => StringComparer.OrdinalIgnoreCase.Equals(value, other);
+    public static bool IsEquivalent(this string value, string other) => StringComparer.OrdinalIgnoreCase.Equals(value, other);
 
     /// <summary>
     /// Gets the L5X element name of the type's containing element. 
diff --git a/src/L5Sharp/Utilities/L5XParser.cs b/src/L5Sharp/Utilities/L5XParser.cs
index 28182cf0..d790f051 100644
--- a/src/L5Sharp/Utilities/L5XParser.cs
+++ b/src/L5Sharp/Utilities/L5XParser.cs
@@ -41,7 +41,6 @@ public static class L5XParser
         {typeof(DataTypeFamily), DataTypeFamily.FromValue},
         {typeof(ElectronicKeying), ElectronicKeying.FromValue},
         {typeof(ExternalAccess), ExternalAccess.FromValue},
-        {typeof(Instruction), Instruction.FromValue},
         {typeof(Keyword), Keyword.FromValue},
         {typeof(OnlineEditType), OnlineEditType.FromValue},
         {typeof(Operator), Operator.FromValue},
diff --git a/tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj b/tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj
new file mode 100644
index 00000000..3dff2ff6
--- /dev/null
+++ b/tests/L5Sharp.Benchmarks/L5Sharp.Benchmarks.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\L5Sharp\L5Sharp.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/tests/L5Sharp.Benchmarks/NeutralTextBenchmarks.cs b/tests/L5Sharp.Benchmarks/NeutralTextBenchmarks.cs
new file mode 100644
index 00000000..b0d3129c
--- /dev/null
+++ b/tests/L5Sharp.Benchmarks/NeutralTextBenchmarks.cs
@@ -0,0 +1,35 @@
+using BenchmarkDotNet.Attributes;
+using L5Sharp.Common;
+
+namespace L5Sharp.Benchmarks;
+
+[MemoryDiagnoser]
+public class NeutralTextBenchmarks
+{
+    private const string Sample =
+        "GRT(SimpleInt,400)XIO(MultiDimensionalArray[1,3].3)CMP(ATN(_Test) > 1.0)[TON(TimerArray[0],?,?),OTU(TestComplexTag.SimpleMember.BoolMember)];";
+    
+    [Params(1000, 10000)]
+    public int N;
+
+    private NeutralText _text;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _text = new NeutralText(Sample);
+    }
+
+    [Benchmark]
+    public List<Instruction> Regex()
+    {
+        var instructions = new List<Instruction>();
+        
+        for (var i = 0; i < N; i++)
+        {
+            instructions.AddRange(_text.Instructions());
+        }
+
+        return instructions;
+    }
+}
\ No newline at end of file
diff --git a/tests/L5Sharp.Benchmarks/Program.cs b/tests/L5Sharp.Benchmarks/Program.cs
new file mode 100644
index 00000000..ce9ecbc4
--- /dev/null
+++ b/tests/L5Sharp.Benchmarks/Program.cs
@@ -0,0 +1,4 @@
+using BenchmarkDotNet.Running;
+using L5Sharp.Benchmarks;
+
+var summary = BenchmarkRunner.Run<NeutralTextBenchmarks>();
\ No newline at end of file
diff --git a/tests/L5Sharp.Samples/Known.cs b/tests/L5Sharp.Samples/Known.cs
index 3dc427a2..f8eb18c5 100644
--- a/tests/L5Sharp.Samples/Known.cs
+++ b/tests/L5Sharp.Samples/Known.cs
@@ -10,7 +10,7 @@ public static class Known
         public static readonly string Test = Path.Combine(Directory, "Test.xml");
         public static readonly string Empty = Path.Combine(Directory, "Empty.xml");
         public static readonly string LotOfTags = Path.Combine(Directory, "LotOfTags.xml");
-        public const string Template = @"C:\Users\admin\Documents\L5X\Template.L5X";
+        public const string Example = @"C:\Users\admin\Documents\L5X\Template.L5X";
 
         public const string DataType = "SimpleType";
         public const string AddOnInstruction = "aoi_Test";
diff --git a/tests/L5Sharp.Tests/Common/ArgumentTests.cs b/tests/L5Sharp.Tests/Common/ArgumentTests.cs
index 5f338daa..dd9f5629 100644
--- a/tests/L5Sharp.Tests/Common/ArgumentTests.cs
+++ b/tests/L5Sharp.Tests/Common/ArgumentTests.cs
@@ -1,6 +1,6 @@
 using FluentAssertions;
 using L5Sharp.Common;
-using L5Sharp.Enums;
+using NUnit.Framework.Internal;
 
 namespace L5Sharp.Tests.Common;
 
@@ -8,26 +8,187 @@ namespace L5Sharp.Tests.Common;
 public class ArgumentTests
 {
     [Test]
-    public void New_FromTagNameString_ShouldNotBeNull()
+    public void Empty_WhenCalled_ShouldHaveExpectedValue()
     {
-        Argument argument = new TagName("Test");
+        var argument = Argument.Empty;
 
-        argument.Should().NotBeNull();
+        argument.Should().Be(string.Empty);
+    }
+
+    [Test]
+    public void Unknown_WhenCalled_ShouldHaveExpectedValue()
+    {
+        var argument = Argument.Unknown;
+
+        argument.Should().Be("?");
     }
 
     [Test]
-    public void New_FromAtomicValue_ShouldNotBeNull()
+    public void IsAtomic_AtomicArgument_ShouldBeTrue()
     {
         Argument argument = 100;
 
+        argument.IsAtomic.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsAtomic_NonAtomicArgument_ShouldBeFalse()
+    {
+        Argument argument = "Test";
+
+        argument.IsAtomic.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsExpression_ExpressionArgument_ShouldBeTrue()
+    {
+        Argument argument = "XIC(MyTagName.Member[1].Active)";
+
+        argument.IsExpression.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsExpression_NonExpressionArgument_ShouldBeFalse()
+    {
+        Argument argument = "MyTagName.Member[1].Active.1";
+
+        argument.IsExpression.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsImmediate_AtomicArgument_ShouldBeTrue()
+    {
+        Argument argument = 100;
+
+        argument.IsImmediate.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsImmediate_StringArgument_ShouldBeTrue()
+    {
+        Argument argument = "'Constant'";
+
+        argument.IsImmediate.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsImmediate_TagNameArgument_ShouldBeFalse()
+    {
+        Argument argument = "MyTagName.Member[1].Active.1";
+
+        argument.IsImmediate.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsTag_TagArgument_ShouldBeTrue()
+    {
+        Argument argument = "MyTagName.Member[1].Active.1";
+
+        argument.IsTag.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsTag_AtomicArgument_ShouldBeFalse()
+    {
+        Argument argument = true;
+
+        argument.IsTag.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsString_TagArgument_ShouldBeTrue()
+    {
+        Argument argument = "'Constant'";
+
+        argument.IsString.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsString_AtomicArgument_ShouldBeFalse()
+    {
+        Argument argument = 1.23;
+
+        argument.IsString.Should().BeFalse();
+    }
+
+    [Test]
+    public void Parse_Null_ShouldBeEmpty()
+    {
+        var argument = Argument.Parse(null);
+
+        argument.Should().Be(string.Empty);
+    }
+
+    [Test]
+    public void Parse_EmptyString_ShouldBeEmpty()
+    {
+        var argument = Argument.Parse(string.Empty);
+
+        argument.Should().Be(string.Empty);
+    }
+
+    [Test]
+    public void Parse_QuestionMark_ShouldBeUnknown()
+    {
+        var argument = Argument.Parse("?");
+
+        argument.Should().Be("?");
+    }
+
+    [Test]
+    public void Parse_StringLiteral_ShouldHaveExpectedValueAndType()
+    {
+        var argument = Argument.Parse("'Test String'");
+
+        argument.Should().NotBeNull();
+        argument.IsString.Should().BeTrue();
+        argument.Should().Be("'Test String'");
+    }
+
+    [Test]
+    public void Parse_AtomicDecimalRadix_ShouldHaveExpectedValueAndType()
+    {
+        var argument = Argument.Parse("100");
+
+        argument.Should().NotBeNull();
+        argument.IsAtomic.Should().BeTrue();
+        argument.Should().Be(100);
+    }
+
+    [Test]
+    public void Parse_AtomicBinaryRadix_ShouldHaveExpectedValueAndType()
+    {
+        var argument = Argument.Parse("2#0010_0110");
+
+        argument.Should().NotBeNull();
+        argument.IsAtomic.Should().BeTrue();
+        argument.Should().Be(38);
+    }
+
+    [Test]
+    public void TagNAme_ValidTagName_ShouldHaveExpectedValueAndType()
+    {
+        var argument = Argument.Parse("MyTagName.Member[1].Active.1");
+
         argument.Should().NotBeNull();
+        argument.IsTag.Should().BeTrue();
+        argument.Should().Be("MyTagName.Member[1].Active.1");
     }
 
     [Test]
-    public void Method_Scenario_ExpectedBehavior()
+    public void ImplicitConversion_TagName_ShouldNotBeExpected()
     {
-        Instruction.XIC.Of("TestTag.Something", 100);
-        
-        Instruction.OR.Of("TestTag.Something", 100);
+        Argument argument = new TagName("Test");
+
+        argument.Should().NotBeNull();
+        argument.Should().Be("Test");
+    }
+
+    [Test]
+    public void ImplicitOperator_Int_ShouldNotBeBeExpected()
+    {
+        Argument argument = 100;
+
+        argument.Should().Be(100);
     }
 }
\ No newline at end of file
diff --git a/tests/L5Sharp.Tests/Common/InstructionTests.cs b/tests/L5Sharp.Tests/Common/InstructionTests.cs
new file mode 100644
index 00000000..93b58162
--- /dev/null
+++ b/tests/L5Sharp.Tests/Common/InstructionTests.cs
@@ -0,0 +1,254 @@
+using FluentAssertions;
+using L5Sharp.Common;
+
+namespace L5Sharp.Tests.Common
+{
+    [TestFixture]
+    public class InstructionTests
+    {
+        [Test]
+        public void New_ValidKey_ShouldNotBeNull()
+        {
+            var instruction = new Instruction("Test");
+
+            instruction.Should().NotBeNull();
+        }
+
+        [Test]
+        public void New_ValidKey_ShouldHaveExpectedDefaults()
+        {
+            var instruction = new Instruction("Test");
+            
+            instruction.Key.Should().Be("Test");
+            instruction.Signature.Should().Be("()");
+            instruction.IsConditional.Should().BeFalse();
+            instruction.CallsRoutine.Should().BeFalse();
+            instruction.CallsTask.Should().BeFalse();
+            instruction.Arguments.Should().BeEmpty();
+            instruction.Text.Should().Be("Test()");
+        }
+        
+        [Test]
+        public void Known_WhenCalled_ShouldNotBeEmpty()
+        {
+            var known = Instruction.Known();
+
+            known.Should().NotBeEmpty();
+        }
+        
+        [Test]
+        public void Keys_WhenCalled_ShouldNotBeEmpty()
+        {
+            var known = Instruction.Keys();
+
+            known.Should().NotBeEmpty();
+        }
+
+        [Test]
+        public void XIC_WhenCalled_ShouldBeExpectedProperties()
+        {
+            var instruction = Instruction.XIC;
+
+            instruction.Key.Should().Be("XIC");
+            instruction.Signature.Should().Contain("()");
+            instruction.IsConditional.Should().BeTrue();
+            instruction.CallsRoutine.Should().BeFalse();
+            instruction.CallsTask.Should().BeFalse();
+            instruction.Arguments.Should().BeEmpty();
+            instruction.Text.Should().Be("XIC()");
+        }
+        
+        [Test]
+        public void OTE_WhenCalled_ShouldBeExpectedProperties()
+        {
+            var instruction = Instruction.OTE;
+
+            instruction.Key.Should().Be("OTE");
+            instruction.Signature.Should().Contain("()");
+            instruction.IsConditional.Should().BeFalse();
+            instruction.CallsRoutine.Should().BeFalse();
+            instruction.CallsTask.Should().BeFalse();
+            instruction.Arguments.Should().BeEmpty();
+            instruction.Text.Should().Be("OTE()");
+        }
+        
+        [Test]
+        public void CallsRoutine_JSR_ShouldBeTrue()
+        {
+            var instruction = Instruction.JSR;
+            
+            instruction.CallsRoutine.Should().BeTrue();
+        }
+        
+        [Test]
+        public void CallsTask_EVENT_ShouldBeTrue()
+        {
+            var instruction = Instruction.EVENT;
+            
+            instruction.CallsTask.Should().BeTrue();
+        }
+
+        [Test]
+        public void Of_XIC_ShouldHaveExpectedValues()
+        {
+            var instruction = Instruction.XIC.Of("MyTagKey");
+
+            instruction.Key.Should().Be("XIC");
+            instruction.Signature.Should().Be("(MyTagKey)");
+            instruction.IsConditional.Should().BeTrue();
+            instruction.CallsRoutine.Should().BeFalse();
+            instruction.CallsTask.Should().BeFalse();
+            instruction.Arguments.Should().HaveCount(1);
+            instruction.Text.Should().Be("XIC(MyTagKey)");
+        }
+
+        [Test]
+        public void Of_TON_ShouldHaveExpectedValues()
+        {
+            var instruction = Instruction.TON.Of("SomeTimer", 5000, 0);
+
+            instruction.Key.Should().Be("TON");
+            instruction.Signature.Should().Be("(SomeTimer,5000,0)");
+            instruction.IsConditional.Should().BeFalse();
+            instruction.CallsRoutine.Should().BeFalse();
+            instruction.CallsTask.Should().BeFalse();
+            instruction.Arguments.Should().HaveCount(3);
+            instruction.Text.Should().Be("TON(SomeTimer,5000,0)");
+        }
+
+        [Test]
+        [TestCase("XIC(MyTagKey);", "XIC", 1)]
+        [TestCase("TON(SomeTimer,5000,0);", "TON", 3)]
+        [TestCase("TON(SomeTimer,?,?);", "TON", 3)]
+        [TestCase("CMP(ATN(_Test) > 1.0);", "CMP", 1)]
+        public void Parse_ValidInput_ShouldHaveExpectedKeyAndArguments(string text, string key, int args)
+        {
+            var instruction = Instruction.Parse(text);
+
+            instruction.Should().NotBeNull();
+            instruction.Key.Should().Be(key);
+            instruction.Arguments.Should().HaveCount(args);
+        }
+
+        [Test]
+        public void Parse_ExpressionTypeInput_ShouldThrowNewException()
+        {
+            FluentActions.Invoking(() => Instruction.Parse("(SomeTag > 1.0)/100")).Should().Throw<ArgumentException>();
+        }
+
+        [Test]
+        public void IsEquivalent_EqualInstructionSignatures_ShouldBeTrue()
+        {
+            var first  = Instruction.XIC.Of("MyTag");
+            var second = Instruction.XIC.Of("MyTag");
+
+            var result = first.IsEquivalent(second);
+
+            result.Should().BeTrue();
+        }
+        
+        [Test]
+        public void IsEquivalent_SameKeyDifferentSignature_ShouldBeFalse()
+        {
+            var first  = Instruction.XIC.Of("MyTag");
+            var second = Instruction.XIC.Of("MyOtherTag");
+
+            var result = first.IsEquivalent(second);
+
+            result.Should().BeFalse();
+        }
+        
+        [Test]
+        public void IsEquivalent_DifferentKeySameSignature_ShouldBeFalse()
+        {
+            var first  = Instruction.XIC.Of("MyTag");
+            var second = Instruction.OTE.Of("MyTag");
+
+            var result = first.IsEquivalent(second);
+
+            result.Should().BeFalse();
+        }
+
+        [Test]
+        public void Equals_EqualInstances_ShouldBeTrue()
+        {
+            var first = Instruction.XIC;
+            var second = Instruction.XIC;
+
+            var result = first.Equals(second);
+
+            result.Should().BeTrue();
+        }
+
+        [Test]
+        public void Equals_SameInstances_ShouldBeTrue()
+        {
+            var first = Instruction.XIC;
+
+            // ReSharper disable once EqualExpressionComparison
+            var result = first.Equals(first);
+
+            result.Should().BeTrue();
+        }
+
+        [Test]
+        public void Equals_Null_ShouldBeFalse()
+        {
+            var first = Instruction.XIC;
+
+            // ReSharper disable once EqualExpressionComparison
+            var result = first.Equals(null);
+
+            result.Should().BeFalse();
+        }
+
+        [Test]
+        public void Equals_EqualString_ShouldBeTrue()
+        {
+            var first = Instruction.TON;
+
+            // ReSharper disable once SuspiciousTypeConversion.Global
+            var result = first.Equals("TON");
+
+            result.Should().BeTrue();
+        }
+
+        [Test]
+        public void EqualsOperator_EqualInstances_ShouldBeTure()
+        {
+            var first = Instruction.XIC;
+            var second = Instruction.XIC;
+
+            var result = first == second;
+
+            result.Should().BeTrue();
+        }
+        
+        [Test]
+        public void NotEqualsOperator_EqualInstances_ShouldBeFalse()
+        {
+            var first = Instruction.XIC;
+            var second = Instruction.XIC;
+
+            var result = first != second;
+
+            result.Should().BeFalse();
+        }
+
+        [Test]
+        public void GetHasCode_WhenCalled_ReturnsHasOfKey()
+        {
+            var instruction = Instruction.XIC;
+            
+            var result = instruction.GetHashCode();
+            
+            result.Should().Be(instruction.Key.GetHashCode());
+        }
+
+        [Test]
+        public void ToString_WhenCalled_ShouldBeKey()
+        {
+            Instruction.OTE.ToString().Should().Be("OTE");
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/L5Sharp.Tests/Common/NeutralTextTests.cs b/tests/L5Sharp.Tests/Common/NeutralTextTests.cs
index 4eb712a5..fe5a4851 100644
--- a/tests/L5Sharp.Tests/Common/NeutralTextTests.cs
+++ b/tests/L5Sharp.Tests/Common/NeutralTextTests.cs
@@ -1,16 +1,26 @@
-using AutoFixture;
+using System.Text;
+using AutoFixture;
 using FluentAssertions;
 using L5Sharp.Common;
-using L5Sharp.Enums;
 
 namespace L5Sharp.Tests.Common
 {
     [TestFixture]
     public class NeutralTextTests
     {
-        private const string TestText =
+        private const string Test01 =
             "[MOV(10,Constant),MOV(0.3,Exponent),GRT(Calculated,0)CPT(Error_SP,( Constant * Calculated ** Exponent) / Calculated * 100),LEQ(Calculated,0)MOV(0,Error_SP)];";
 
+        private const string Test02 =
+            "GRT(SimpleInt,400)XIO(MultiDimensionalArray[1,3].3)CMP(ATN(_Test) > 1.0)[TON(TimerArray[0],?,?),OTU(TestComplexTag.SimpleMember.BoolMember)];";
+        
+
+        [Test]
+        public void Method_Scenario_ExpectedBehavior()
+        {
+           
+        }
+        
         [Test]
         public void New_NullText_ShouldThrowArgumentNullException()
         {
@@ -18,11 +28,11 @@ public void New_NullText_ShouldThrowArgumentNullException()
         }
 
         [Test]
-        public void New_EmptyString_ShouldBeEqualToEmpty()
+        public void New_EmptyString_ShouldBeSemiColon()
         {
             var text = new NeutralText(string.Empty);
 
-            text.Should().BeEquivalentTo(NeutralText.Empty);
+            text.ToString().Should().Be(";");
         }
 
         [Test]
@@ -42,7 +52,15 @@ public void New_ValidText_ShouldNotBeNull()
 
             text.Should().NotBeNull();
         }
-
+        
+        [Test]
+        public void IsBalanced_ValidText_ShouldBeTrue()
+        {
+            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
+            
+            text.IsBalanced.Should().BeTrue();
+        }
+        
         [Test]
         public void IsBalanced_Unbalanced_ShouldBeFalse()
         {
@@ -50,31 +68,15 @@ public void IsBalanced_Unbalanced_ShouldBeFalse()
 
             text.IsBalanced.Should().BeFalse();
         }
-
+        
         [Test]
         public void IsBalanced_TestText_ShouldBeTrue()
         {
-            var text = new NeutralText(TestText);
+            var text = new NeutralText(Test01);
 
             text.IsBalanced.Should().BeTrue();
         }
 
-        [Test]
-        public void IsInstruction_TestText_ShouldBeFalse()
-        {
-            var text = new NeutralText(TestText);
-
-            text.IsSingle.Should().BeFalse();
-        }
-
-        [Test]
-        public void IsInstruction_SingleInstruction_ShouldBeTrue()
-        {
-            var text = new NeutralText("XIC(SomeTag)");
-
-            text.IsSingle.Should().BeTrue();
-        }
-
         [Test]
         public void Empty_WhenCalled_ShouldBeEmptyString()
         {
@@ -84,313 +86,151 @@ public void Empty_WhenCalled_ShouldBeEmptyString()
         }
 
         [Test]
-        public void ContainsKey_Empty_ShouldBeFalse()
+        public void Contains_HasEmptyText_ShouldBeFalse()
         {
             var text = NeutralText.Empty;
 
-            var result = text.Contains("XIC");
+            var result = text.Contains("XIC(Tag.Status.Enabled)");
 
             result.Should().BeFalse();
         }
 
         [Test]
-        public void ContainsKey_ValidInstruction_ShouldBeTrue()
+        public void Contains_HasInstructionText_ShouldBeTrue()
         {
             var text = new NeutralText(
                 "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
 
-            var result = text.Contains("XIC");
+            var result = text.Contains("XIC(Tag.Status.Enabled)");
 
             result.Should().BeTrue();
         }
 
         [Test]
-        public void ContainsKey_CustomInstruction_ShouldBeTrue()
-        {
-            var text = new NeutralText(
-                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),aoiTIMER(Timer,?,?)];");
-
-            var result = text.Contains("aoiTIMER");
-
-            result.Should().BeTrue();
-        }
-
-        [Test]
-        public void ContainsSignature_Empty_ShouldBeFalse()
-        {
-            var text = NeutralText.Empty;
-
-            var result = text.Contains(Instruction.XIC);
-
-            result.Should().BeFalse();
-        }
-
-        [Test]
-        public void ContainsSignature_ValidInstruction_ShouldBeTrue()
+        public void Contains_HasTagName_ShouldBeTrue()
         {
             var text = new NeutralText(
                 "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
 
-            var result = text.Contains(Instruction.XIC);
+            var result = text.Contains("Tag.Status.Enabled");
 
             result.Should().BeTrue();
         }
-
-        [Test]
-        public void ContainsText_Empty_ShouldBeFalse()
-        {
-            var text = NeutralText.Empty;
-
-            var result = text.Contains((NeutralText) "XIC(Tag.Status.Enabled)");
-
-            result.Should().BeFalse();
-        }
-
-        [Test]
-        public void ContainsText_ValidTagName_ShouldBeTrue()
-        {
-            var text = new NeutralText(
-                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
-
-            var result = text.Contains((NeutralText) "XIC(Tag.Status.Enabled)");
-
-            result.Should().BeTrue();
-        }
-
+        
         [Test]
-        public void ContainsTag_Empty_ShouldBeFalse()
+        public void Instructions_Empty_ShouldBeEmpty()
         {
             var text = NeutralText.Empty;
 
-            var result = text.Contains(new TagName("Tag.Status.Enabled"));
-
-            result.Should().BeFalse();
-        }
-
-        [Test]
-        public void ContainsTag_ValidTagName_ShouldBeTrue()
-        {
-            var text = new NeutralText(
-                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
-
-            var result = text.Contains(new TagName("Tag.Status.Enabled"));
+            var result = text.Instructions();
 
-            result.Should().BeTrue();
+            result.Should().BeEmpty();
         }
-
+        
         [Test]
-        public void Split_SimpleTextWithMultipleInstruction_ShouldHaveExpectedCount()
+        public void Instructions_SimpleTextWithMultipleInstruction_ShouldHaveExpectedCount()
         {
             var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
 
-            var instructions = text.Split();
+            var instructions = text.Instructions();
 
             instructions.Should().HaveCount(3);
         }
 
         [Test]
-        public void Split_SingleInstruction_ShouldHaveExpectedCount()
+        public void Instructions_SingleInstruction_ShouldHaveExpectedCount()
         {
             var text = new NeutralText("XIC(SomeBit)");
 
-            var instructions = text.Split();
+            var instructions = text.Instructions();
 
             instructions.Should().HaveCount(1);
         }
 
         [Test]
-        public void Split_SingleInstruction_ShouldEqualOriginal()
-        {
-            var text = new NeutralText("XIC(SomeBit)");
-
-            var result = text.Split();
-
-            result.First().Should().BeEquivalentTo(text);
-        }
-
-        [Test]
-        public void Tags_SimpleTextWithMultipleTags_ShouldHaveExpectedCount()
+        public void Instructions_CustomInstructions_ReturnsExpected()
         {
-            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
+            var text = new NeutralText(
+                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),aoiTIMER(Timer,?,?)];");
 
-            var tagNames = text.Tags();
+            var instructions = text.Instructions();
 
-            tagNames.Should().HaveCount(3);
+            instructions.Should().HaveCount(4);
         }
 
         [Test]
-        public void TagsIn_OTE_ShouldHaveExpectedTagName()
+        public void Instructions_SingleInstruction_ShouldEqualOriginal()
         {
-            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
+            var text = new NeutralText("XIC(SomeBit)");
 
-            var tagNames = text.TagsIn(Instruction.OTE);
+            var result = text.Instructions();
 
-            tagNames.Should().HaveCount(1);
+            result.First().Should().BeEquivalentTo(text);
         }
-
+        
         [Test]
-        public void Split_WithExistingInstructionPresent_ShouldContainExpectedText()
+        public void InstructionsBy_WithExistingInstructionPresent_ShouldContainExpectedText()
         {
             var text = new NeutralText(
                 "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
 
-            var result = text.SplitBy(Instruction.XIC).ToList();
+            var result = text.Instructions(Instruction.XIC).ToList();
 
             result.Should().Contain("XIC(Tag.Status.Active)");
             result.Should().Contain("XIC(Tag.Status.Enabled)");
         }
 
         [Test]
-        public void Split_WithExistingInstructionPresent_ShouldHaveExpectedCount()
+        public void InstructionsBy_WithExistingInstructionPresent_ShouldHaveExpectedCount()
         {
             var text = new NeutralText(
                 "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
 
-            var result = text.SplitBy(Instruction.XIC);
+            var result = text.Instructions(Instruction.XIC);
 
             result.Should().HaveCount(2);
         }
-
-        [Test]
-        public void Operands_Empty_ShouldBeEmpty()
-        {
-            var text = NeutralText.Empty;
-
-            var result = text.Operands();
-
-            result.Should().BeEmpty();
-        }
-
-        [Test]
-        public void Operands_WhenCalled_ReturnsExpectedCount()
-        {
-            var text = new NeutralText(TestText);
-
-            var operands = text.Operands();
-
-            operands.Should().HaveCount(12);
-        }
-
-        [Test]
-        public void OperandsByKey_Default_ReturnsExpectedCount()
-        {
-            var text = new NeutralText(TestText);
-
-            var results = text.OperandsByKey().ToList();
-
-            results.Should().HaveCount(6);
-
-            foreach (var pair in results)
-            {
-                pair.Key.Should().NotBeEmpty();
-                pair.Value.Should().NotBeEmpty();
-            }
-        }
-
-        [Test]
-        public void OperandsByKey_MOV_ReturnsExpectedCount()
-        {
-            var text = new NeutralText(TestText);
-
-            var results = text.OperandsByKey(Instruction.MOV).ToList();
-
-            results.Should().HaveCount(3);
-
-            foreach (var pair in results)
-            {
-                pair.Key.Should().Be(Instruction.MOV);
-                pair.Value.Should().HaveCount(2);
-            }
-        }
-
-        [Test]
-        public void OperandsByKey_stringMOV_ReturnsExpectedCount()
-        {
-            var text = new NeutralText(TestText);
-
-            var results = text.OperandsByKey("MOV").ToList();
-
-            results.Should().HaveCount(3);
-
-            foreach (var pair in results)
-            {
-                pair.Key.Should().Be(Instruction.MOV);
-                pair.Value.Should().HaveCount(2);
-            }
-        }
-
-        [Test]
-        public void Instructions_WhenCalled_ReturnsExpected()
-        {
-            var text = new NeutralText(
-                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),TON(Timer,?,?)];");
-
-            var instructions = text.Instructions();
-
-            instructions.Should().HaveCount(4);
-        }
-
-        [Test]
-        public void Instructions_Empty_ShouldBeEmpty()
-        {
-            var text = NeutralText.Empty;
-
-            var result = text.Instructions();
-
-            result.Should().BeEmpty();
-        }
-
-        [Test]
-        public void Instructions_CustomInstructions_ReturnsExpected()
-        {
-            var text = new NeutralText(
-                "[XIC(Tag.Status.Active),XIC(Tag.Status.Enabled)][MOV(15000,Timer.PRE),aoiTIMER(Timer,?,?)];");
-
-            var instructions = text.Instructions();
-
-            instructions.Should().HaveCount(4);
-        }
-
+        
         [Test]
-        public void Keys_Empty_ShouldBeEmpty()
+        public void Keywords_TextWithKeywords_ShouldHaveExpectedCount()
         {
-            var text = NeutralText.Empty;
-
-            var result = text.Keys();
-
-            result.Should().BeEmpty();
+            var text = new NeutralText("if Tag >= 10 then");
+            
+            var keywords = text.Keywords().ToList();
+            
+            keywords.Should().HaveCount(2);
         }
 
         [Test]
-        public void Keys_ValidInstructions_ShouldReturnExpectedCount()
+        public void Keywords_TextWithNoKeywords_ShouldBeEmpty()
         {
-            var text = new NeutralText(TestText);
-
-            var result = text.Keys();
-
-            result.Should().HaveCount(6);
+            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
+            
+            var keywords = text.Keywords().ToList();
+            
+            keywords.Should().BeEmpty();
         }
 
         [Test]
-        public void References()
+        public void Tags_SimpleTextWithMultipleTags_ShouldHaveExpectedCount()
         {
-            var text = new NeutralText(TestText);
+            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
 
-            var references = text.References().ToList();
+            var tagNames = text.Tags();
 
-            references.Should().NotBeEmpty();
+            tagNames.Should().HaveCount(3);
         }
 
         [Test]
-        public void ReferencesArrayTest()
+        public void TagsIn_OTE_ShouldHaveExpectedTagName()
         {
-            var text = new NeutralText("MOV(Archive_Previous_Daily_Mtr09.CLOSE_TIME,Daily_CloseTime_LS[8])");
+            var text = new NeutralText("[XIC(SomeBit),XIO(AnotherBit)]OTE(OutputBit);");
 
-            var references = text.References().ToList();
+            var tagNames = text.TagsIn(Instruction.OTE);
 
-            references.Should().NotBeEmpty();
+            tagNames.Should().HaveCount(1);
         }
-
+        
         [Test]
         public void HasPattern_ConcatenatedXICOTE_ShouldBeTrue()
         {
@@ -401,28 +241,6 @@ public void HasPattern_ConcatenatedXICOTE_ShouldBeTrue()
 
             result.Should().BeTrue();
         }
-
-        [Test]
-        public void SplitBy_ValidPattern_ShouldWork()
-        {
-            var text = new NeutralText(
-                "[XIC(Input_Data.Pt00.Data)OTE(Ch0.ChData),XIC(Input_Data.Pt00.Fault)OTE(Ch0.ChFault)];");
-
-            var result = text.SplitBy(string.Concat(Instruction.XIC.Signature, Instruction.OTE.Signature)).ToList();
-
-            result.Should().HaveCount(2);
-        }
-
-        [Test]
-        public void Operands_CptInstruction_ShouldHaveCountTwo()
-        {
-            var text = new NeutralText(
-                "CPT(UDT.alg_Value,((ai_Signal - UDT.sp_RawMin) / (UDT.sp_RawMax - UDT.sp_RawMin)) * (UDT.sp_EUMax - UDT.sp_EUMin) + UDT.sp_EUMin);");
-
-            var operands = text.Operands().ToList();
-
-            operands.Should().HaveCount(2);
-        }
         
         [Test]
         public void StructuredText_New_ShouldNotBeNull()
@@ -438,10 +256,8 @@ public void StructuredText_ShouldHaveExpected()
             var text = new NeutralText("SimpleBool := TestComplexTag.SimpleMember.BoolMember;");
 
             text.IsEmpty.Should().BeFalse();
-            text.IsSingle.Should().BeFalse();
             text.IsBalanced.Should().BeTrue();
             text.Instructions().Should().BeEmpty();
-            text.Keys().Should().BeEmpty();
             text.Tags().Should().HaveCount(2);
         }
     }
diff --git a/tests/L5Sharp.Tests/Common/TagNameTests.cs b/tests/L5Sharp.Tests/Common/TagNameTests.cs
index 2dfaa18c..2585321e 100644
--- a/tests/L5Sharp.Tests/Common/TagNameTests.cs
+++ b/tests/L5Sharp.Tests/Common/TagNameTests.cs
@@ -81,6 +81,26 @@ public void New_ComplexName_ShouldBeExpected()
             tagName.IsEmpty.Should().BeFalse();
             tagName.IsQualified.Should().BeTrue();
         }
+        
+        [Test]
+        public void IsQualified_QualifiedTagNameWithAllPossibleMemberTypes_ShouldBeTrue()
+        {
+            var tagName = new TagName("Module:1:I.TagName.Member[1].SubTag.Another[12,13,14].Value.12");
+
+            var result = tagName.IsQualified;
+
+            result.Should().BeTrue();
+        }
+
+        [Test]
+        public void IsQualified_ArraySegmentOnly_ShouldBeFalse()
+        {
+            var tagName = new TagName("[1]");
+            
+            var result = tagName.IsQualified;
+            
+            result.Should().BeFalse();
+        }
 
         [Test]
         public void Root_WhenCalledManyTimes_ShouldBeEfficient()
diff --git a/tests/L5Sharp.Tests/Enums/InstructionTests.cs b/tests/L5Sharp.Tests/Enums/InstructionTests.cs
deleted file mode 100644
index 4ee75bd3..00000000
--- a/tests/L5Sharp.Tests/Enums/InstructionTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-using FluentAssertions;
-using L5Sharp.Enums;
-
-namespace L5Sharp.Tests.Enums
-{
-    [TestFixture]
-    public class InstructionTests
-    {
-        [Test]
-        public void List_WhenCalled_ReturnsAllInstructions()
-        {
-            var list = Instruction.All();
-
-            list.Should().NotBeEmpty();
-        }
-        [Test]
-        public void XIC_WhenCalled_ShouldBeExpectedProperties()
-        {
-            var instruction = Instruction.XIC;
-
-            instruction.Name.Should().Be("XIC");
-            instruction.Signature.Should().Contain("XIC");
-            instruction.Destructive.Should().BeFalse();
-        }
-
-        [Test]
-        public void Of_XIC_ShouldBeExpectedOutput()
-        {
-            var xic = Instruction.XIC;
-
-            var text = xic.Of("MyTagName");
-
-            text.ToString().Should().Be("XIC(MyTagName)");
-        }
-        
-        [Test]
-        public void Of_TON_ShouldBeExpectedOutput()
-        {
-            var text = Instruction.TON.Of("SomeTimer", 5000, 0);
-
-            text.ToString().Should().Be("TON(SomeTimer,5000,0)");
-        }
-    }
-}
\ No newline at end of file
diff --git a/tests/L5Sharp.Tests/Enums/KeywordTests.cs b/tests/L5Sharp.Tests/Enums/KeywordTests.cs
index 7daaba4e..67e32c48 100644
--- a/tests/L5Sharp.Tests/Enums/KeywordTests.cs
+++ b/tests/L5Sharp.Tests/Enums/KeywordTests.cs
@@ -6,18 +6,6 @@ namespace L5Sharp.Tests.Enums;
 [TestFixture]
 public class KeywordTests
 {
-    [Test]
-    public void RightBracket_WhenCalled_ShouldNotBeNull()
-    {
-        Keyword.RightBracket.Should().NotBeNull();
-    }
-
-    [Test]
-    public void BracketOpen_WhenCalled_ShouldNotBeNull()
-    {
-        Keyword.LeftBracket.Should().NotBeNull();
-    }
-
     [Test]
     public void By_WhenCalled_ShouldNotBeNull()
     {
@@ -30,24 +18,12 @@ public void Case_WhenCalled_ShouldNotBeNull()
         Keyword.Case.Should().NotBeNull();
     }
 
-    [Test]
-    public void Comma_WhenCalled_ShouldNotBeNull()
-    {
-        Keyword.Comma.Should().NotBeNull();
-    }
-
     [Test]
     public void Do_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Do.Should().NotBeNull();
     }
 
-    [Test]
-    public void Dot_WhenCalled_ShouldNotBeNull()
-    {
-        Keyword.Period.Should().NotBeNull();
-    }
-
     [Test]
     public void Else_WhenCalled_ShouldNotBeNull()
     {
@@ -107,61 +83,55 @@ public void Goto_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Goto.Should().NotBeNull();
     }
-    
+
     [Test]
     public void If_WhenCalled_ShouldNotBeNull()
     {
         Keyword.If.Should().NotBeNull();
     }
-    
+
     [Test]
     public void Of_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Of.Should().NotBeNull();
     }
-    
-    [Test]
-    public void Parenthesis_WhenCalled_ShouldNotBeNull()
-    {
-        Keyword.LeftParenthesis.Should().NotBeNull();
-    }
-    
+
     [Test]
     public void Repeat_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Repeat.Should().NotBeNull();
     }
-    
+
     [Test]
     public void Return_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Return.Should().NotBeNull();
     }
-    
+
     [Test]
     public void Then_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Then.Should().NotBeNull();
     }
-    
+
     [Test]
     public void This_WhenCalled_ShouldNotBeNull()
     {
         Keyword.This.Should().NotBeNull();
     }
-    
+
     [Test]
     public void To_WhenCalled_ShouldNotBeNull()
     {
         Keyword.To.Should().NotBeNull();
     }
-    
+
     [Test]
     public void Until_WhenCalled_ShouldNotBeNull()
     {
         Keyword.Until.Should().NotBeNull();
     }
-    
+
     [Test]
     public void While_WhenCalled_ShouldNotBeNull()
     {
diff --git a/tests/L5Sharp.Tests/L5XBasicTests.cs b/tests/L5Sharp.Tests/L5XBasicTests.cs
index da42121f..b8bb6735 100644
--- a/tests/L5Sharp.Tests/L5XBasicTests.cs
+++ b/tests/L5Sharp.Tests/L5XBasicTests.cs
@@ -32,7 +32,7 @@ public void New_LotsOfTags_ShouldNotBeNull()
     [Test]
     public void New_Template_ShouldNotBeNull()
     {
-        var element = XElement.Load(Known.Template);
+        var element = XElement.Load(Known.Example);
         
         var l5X = new L5X(element);
 
diff --git a/tests/L5Sharp.Tests/L5XTagTests.cs b/tests/L5Sharp.Tests/L5XTagTests.cs
index cd90d73b..f60f433f 100644
--- a/tests/L5Sharp.Tests/L5XTagTests.cs
+++ b/tests/L5Sharp.Tests/L5XTagTests.cs
@@ -53,7 +53,7 @@ public void References_AgainstKnownTest_ShouldNotBeEmpty()
     [Test]
     public void References_AgainstAllTags_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
         var tags = content.Find<Tag>().SelectMany(t => t.Members()).ToList();
 
         var references = tags.Select(t => new {t.TagName, Refernces = t.References()}).ToList();
diff --git a/tests/L5Sharp.Tests/L5XTemplateTests.cs b/tests/L5Sharp.Tests/L5XTemplateTests.cs
index 9da53f4f..49c3b857 100644
--- a/tests/L5Sharp.Tests/L5XTemplateTests.cs
+++ b/tests/L5Sharp.Tests/L5XTemplateTests.cs
@@ -11,7 +11,7 @@ public class L5XTemplateTests
     [Test]
     public void DataTypes_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.DataTypes.ToList();
 
@@ -21,7 +21,7 @@ public void DataTypes_WhenCalled_ShouldNotBeEmpty()
     [Test]
     public void Modules_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.Modules.ToList();
 
@@ -31,7 +31,7 @@ public void Modules_WhenCalled_ShouldNotBeEmpty()
     [Test]
     public void Instructions_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.Instructions.ToList();
 
@@ -41,7 +41,7 @@ public void Instructions_WhenCalled_ShouldNotBeEmpty()
     [Test]
     public void Tags_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.Tags.ToList();
 
@@ -51,7 +51,7 @@ public void Tags_WhenCalled_ShouldNotBeEmpty()
     [Test]
     public void TagsAll_WhenEnumerated_ShouldWork()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var stopwatch = new Stopwatch();
         stopwatch.Start();
@@ -65,7 +65,7 @@ public void TagsAll_WhenEnumerated_ShouldWork()
     [Test]
     public void Programs_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.Programs.ToList();
 
@@ -75,7 +75,7 @@ public void Programs_WhenCalled_ShouldNotBeEmpty()
     [Test]
     public void Tasks_WhenCalled_ShouldNotBeEmpty()
     {
-        var content = L5X.Load(Known.Template);
+        var content = L5X.Load(Known.Example);
 
         var components = content.Tasks.ToList();
 
diff --git a/tests/L5Sharp.Tests/ProofTesting.cs b/tests/L5Sharp.Tests/ProofTesting.cs
index 4c4e9feb..623d97a9 100644
--- a/tests/L5Sharp.Tests/ProofTesting.cs
+++ b/tests/L5Sharp.Tests/ProofTesting.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using FluentAssertions;
+using L5Sharp.Elements;
 using L5Sharp.Samples;
 
 namespace L5Sharp.Tests;
@@ -34,4 +35,14 @@ public void Scratch(int input)
         var character = (char)(input / 200 + 'A');
         Console.WriteLine(character);
     }
+
+    [Test]
+    public void Query()
+    {
+        var content = L5X.Load(Known.Example);
+
+        var rungs = content.Find<Rung>().ToList();
+
+        rungs.Should().NotBeEmpty();
+    }
 }
\ No newline at end of file