Define a grammar with rust-sitter

Signed-off-by: Rachel <508861+Ryex@users.noreply.github.com>
2024-03-22 04:09:04 -07:00
parent 2425d8145a
commit 78c13331a1
21 changed files with 54303 additions and 18 deletions
--- a/ic10emu/Cargo.lock
+++ b/ic10emu/Cargo.lock
--- a/ic10emu/Cargo.toml
+++ b/ic10emu/Cargo.toml
@@ -11,4 +11,16 @@ crate-type = ["lib"]

 [dependencies]
 const-crc32 = "1.3.0"
+phf = "0.11.2"
+regex = "1.10.3"
+# rust-sitter = "0.4.1"
+
+rust-sitter = { path = "E:\\Projects\\rust-sitter\\runtime"}
+
+[build-dependencies]
+convert_case = "0.6.0"
+phf_codegen = "0.11.2"
+regex = "1.10.3"
+# rust-sitter-tool = "0.4.1"
+rust-sitter-tool = { path = "E:\\Projects\\rust-sitter\\tool"}

--- a/ic10emu/FullStationpedia.json
+++ b/ic10emu/FullStationpedia.json
--- a/ic10emu/build.rs
+++ b/ic10emu/build.rs
@@ -0,0 +1,435 @@
+use convert_case::{Case, Casing};
+use std::{
+    collections::HashSet,
+    env,
+    fs::{self, File},
+    io::{BufRead, BufReader, BufWriter, Read, Write},
+    path::{Path, PathBuf},
+};
+
+fn write_logictypes(logictypes_grammar: &mut HashSet<String>) {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let dest_path = Path::new(&out_dir).join("logictypes.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+
+    let mut logictype_set = ::phf_codegen::Set::new();
+    let mut logictype_lookup_map_builder = ::phf_codegen::Map::new();
+    let l_infile = Path::new("data/logictypes.txt");
+    let l_contents = fs::read_to_string(l_infile).unwrap();
+
+    for line in l_contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(3, ' ');
+        let name = it.next().unwrap();
+        let val_str = it.next().unwrap();
+        let val: Option<u8> = val_str.parse().ok();
+
+        logictype_set.entry(name);
+        logictypes_grammar.insert(name.to_string());
+        if let Some(v) = val {
+            logictype_lookup_map_builder.entry(name, &format!("{}u8", v));
+        }
+    }
+
+    let mut slotlogictype_set = ::phf_codegen::Set::new();
+    let mut slotlogictype_lookup_map_builder = ::phf_codegen::Map::new();
+    let sl_infile = Path::new("data/slotlogictypes.txt");
+    let sl_contents = fs::read_to_string(sl_infile).unwrap();
+
+    for line in sl_contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(3, ' ');
+        let name = it.next().unwrap();
+        let val_str = it.next().unwrap();
+        let val: Option<u8> = val_str.parse().ok();
+
+        slotlogictype_set.entry(name);
+        logictypes_grammar.insert(name.to_string());
+        if let Some(v) = val {
+            slotlogictype_lookup_map_builder.entry(name, &format!("{}u8", v));
+        }
+    }
+
+    write!(
+        &mut writer,
+        "pub(crate) const LOGIC_TYPES: phf::Set<&'static str> = {};\n",
+        logictype_set.build()
+    )
+    .unwrap();
+
+    write!(
+        &mut writer,
+        "pub(crate) const LOGIC_TYPE_LOOKUP: phf::Map<&'static str, u8> = {};\n",
+        logictype_lookup_map_builder.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/logictypes.txt");
+
+    write!(
+        &mut writer,
+        "pub(crate) const SLOT_LOGIC_TYPES: phf::Set<&'static str> = {};\n",
+        slotlogictype_set.build()
+    )
+    .unwrap();
+
+    write!(
+        &mut writer,
+        "pub(crate) const SLOT_TYPE_LOOKUP: phf::Map<&'static str, u8> = {};\n",
+        slotlogictype_lookup_map_builder.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/slotlogictypes.txt");
+}
+
+fn write_enums(enums_grammar: &mut HashSet<String>) {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let dest_path = Path::new(&out_dir).join("enums.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+
+    let mut enums_set = ::phf_codegen::Set::new();
+    let mut enums_lookup_map_builder = ::phf_codegen::Map::new();
+    let mut check_set = std::collections::HashSet::new();
+    let e_infile = Path::new("data/enums.txt");
+    let e_contents = fs::read_to_string(e_infile).unwrap();
+
+    for line in e_contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(2, ' ');
+        let name = it.next().unwrap();
+        let val_str = it.next().unwrap();
+        let val: Option<u8> = val_str.parse().ok();
+
+        if !check_set.contains(name) {
+            enums_set.entry(name);
+            enums_grammar.insert(name.to_string());
+            check_set.insert(name);
+        }
+
+        if let Some(v) = val {
+            enums_lookup_map_builder.entry(name, &format!("{}u8", v));
+        }
+    }
+
+    write!(
+        &mut writer,
+        "pub(crate) const ENUMS: phf::Set<&'static str> = {};\n",
+        enums_set.build()
+    )
+    .unwrap();
+
+    write!(
+        &mut writer,
+        "pub(crate) const ENUM_LOOKUP: phf::Map<&'static str, u8> = {};\n",
+        enums_lookup_map_builder.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/enums.txt");
+}
+
+fn write_modes(logictypes_grammar: &mut HashSet<String>) {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let dest_path = Path::new(&out_dir).join("modes.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+
+    let mut batchmode_set = ::phf_codegen::Set::new();
+    let mut batchmode_lookup_map_builder = ::phf_codegen::Map::new();
+    let b_infile = Path::new("data/batchmodes.txt");
+    let b_contents = fs::read_to_string(b_infile).unwrap();
+
+    for line in b_contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(3, ' ');
+        let name = it.next().unwrap();
+        let val_str = it.next().unwrap();
+        let val: Option<u8> = val_str.parse().ok();
+
+        batchmode_set.entry(name);
+        logictypes_grammar.insert(name.to_string());
+        if let Some(v) = val {
+            batchmode_lookup_map_builder.entry(name, &format!("{}u8", v));
+        }
+    }
+
+    let mut reagentmode_set = ::phf_codegen::Set::new();
+    let mut reagentmode_lookup_map_builder = ::phf_codegen::Map::new();
+    let r_infile = Path::new("data/reagentmodes.txt");
+    let r_contents = fs::read_to_string(r_infile).unwrap();
+
+    for line in r_contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(3, ' ');
+        let name = it.next().unwrap();
+        let val_str = it.next().unwrap();
+        let val: Option<u8> = val_str.parse().ok();
+
+        reagentmode_set.entry(name);
+        logictypes_grammar.insert(name.to_string());
+        if let Some(v) = val {
+            reagentmode_lookup_map_builder.entry(name, &format!("{}u8", v));
+        }
+    }
+
+    write!(
+        &mut writer,
+        "pub(crate) const BATCH_MODES: phf::Set<&'static str> = {};\n",
+        batchmode_set.build()
+    )
+    .unwrap();
+
+    write!(
+        &mut writer,
+        "pub(crate) const BATCH_MODE_LOOKUP: phf::Map<&'static str, u8> = {};\n",
+        batchmode_lookup_map_builder.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/batchmodes.txt");
+
+    write!(
+        &mut writer,
+        "pub(crate) const REAGENT_MODES: phf::Set<&'static str> = {};\n",
+        reagentmode_set.build()
+    )
+    .unwrap();
+
+    write!(
+        &mut writer,
+        "pub(crate) const REAGENT_MODE_LOOKUP: phf::Map<&'static str, u8> = {};\n",
+        reagentmode_lookup_map_builder.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/reagentmodes.txt");
+}
+
+fn write_constants(constants_grammar: &mut HashSet<String>) {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let dest_path = Path::new(&out_dir).join("constants.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+
+    let mut constants_set = ::phf_codegen::Set::new();
+    let mut constants_lookup_map_builder = ::phf_codegen::Map::new();
+    let infile = Path::new("data/constants.txt");
+    let contents = fs::read_to_string(infile).unwrap();
+
+    for line in contents.lines().filter(|l| !l.trim().is_empty()) {
+        let mut it = line.splitn(3, ' ');
+        let name = it.next().unwrap();
+        let constant = it.next().unwrap();
+
+        constants_set.entry(name);
+        constants_grammar.insert(name.to_string());
+        constants_lookup_map_builder.entry(name, constant);
+    }
+
+    write!(
+        &mut writer,
+        "pub(crate) const CONSTANTS: phf::Set<&'static str> = {};\n",
+        constants_set.build()
+    )
+    .unwrap();
+
+    println!("cargo:rerun-if-changed=data/constants.txt");
+}
+
+fn write_logictypes_grammar(logictypes: &HashSet<String>) {
+    let dest_path = Path::new("src/grammar/ic10").join("logictypes.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+    write!(
+        &mut writer,
+        "// GENERATED CODE DO NOT MODIFY\n\
+         #[derive(PartialEq, Debug)]\n\
+         pub enum LogicType {{\n\
+        "
+    )
+    .unwrap();
+    for typ in logictypes {
+        let enum_name = typ.to_case(Case::Pascal);
+
+        write!(
+            &mut writer,
+            "     {}( #[rust_sitter::leaf(text = \"{typ}\", transform = |s| s.to_string() )] String ),\n",
+            &enum_name
+        )
+        .unwrap();
+    }
+    write!(&mut writer, "}}\n").unwrap();
+}
+
+fn write_enums_grammar(enums: HashSet<String>) {
+
+    let dest_path = Path::new("src/grammar/ic10").join("enums.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+    write!(
+        &mut writer,
+        "// GENERATED CODE DO NOT MODIFY\n\
+         #[derive(PartialEq, Debug)]\n\
+         pub enum Enum {{\n\
+        "
+    )
+    .unwrap();
+    for typ in enums {
+        let enum_name = typ.replace(".", "").to_case(Case::Pascal);
+
+        write!(
+            &mut writer,
+            "     {}( #[rust_sitter::leaf(text = \"{typ}\", transform = |s| s.to_string() )] String ),\n",
+            &enum_name
+        )
+        .unwrap();
+    }
+    write!(&mut writer, "}}\n").unwrap();
+}
+
+fn write_constants_grammar(constants: HashSet<String>) {
+
+    let dest_path = Path::new("src/grammar/ic10").join("constants.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+    write!(
+        &mut writer,
+        "// GENERATED CODE DO NOT MODIFY\n\
+         #[derive(PartialEq, Debug)]\n\
+         pub enum Constant {{\n\
+        "
+    )
+    .unwrap();
+    for typ in constants {
+        let enum_name = typ.replace(".", "").to_case(Case::Pascal);
+
+        write!(
+            &mut writer,
+            "     {}( #[rust_sitter::leaf(text = \"{typ}\", transform = |s| s.to_string() )] String ),\n",
+            &enum_name
+        )
+        .unwrap();
+    }
+    write!(&mut writer, "}}\n").unwrap();
+}
+
+fn write_instructions_grammar() {
+
+    let dest_path = Path::new("src/grammar/ic10").join("instructions.rs");
+    let output_file = File::create(dest_path).unwrap();
+    let mut writer = BufWriter::new(&output_file);
+
+    let mut instructions = HashSet::new();
+    let infile = Path::new("data/instructions.txt");
+    let contents = fs::read_to_string(infile).unwrap();
+
+    for line in contents.lines() {
+        let mut it = line.split(' ');
+        let instruction = it.next().unwrap();
+        instructions.insert(instruction.to_string());
+    }
+    write!(
+        &mut writer,
+        "// GENERATED CODE DO NOT MODIFY\n\
+         #[derive(PartialEq, Debug)]\n\
+         pub enum InstructionOp {{\n\
+        "
+    )
+    .unwrap();
+    for typ in instructions {
+        let enum_name = typ.to_case(Case::Pascal);
+
+        write!(
+            &mut writer,
+            "     {}( #[rust_sitter::leaf(text = \"{typ}\", transform = |s| s.to_string() )] String ),\n",
+            &enum_name
+        )
+        .unwrap();
+    }
+    write!(&mut writer, "}}\n").unwrap();
+
+}
+
+fn patch_grammar() {
+    let out_path = env::var_os("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_path);
+    let src_dir = Path::new("src");
+    fs::copy(
+        src_dir.join("grammar.rs"),
+        out_dir.join("grammar_unpatched.rs"),
+    )
+    .unwrap();
+    {
+        let grammar_file = File::open(src_dir.join("grammar.rs")).unwrap();
+        let output_file = File::create(out_dir.join("grammar_patched.rs")).unwrap();
+        let mut writer = BufWriter::new(output_file);
+
+        let patch_regex = regex::Regex::new(r"^\s+// PATCH ([\w/.]+)\s*$").unwrap();
+
+        let mut patch_marker: Option<regex::Regex> = None;
+        for line in BufReader::new(grammar_file).lines().flatten() {
+            if let Some(marker) = &patch_marker {
+                if let Some(_) = marker.captures(&line) {
+                    write!(&mut writer, "{}\n", line).unwrap();
+                    patch_marker = None;
+                } else {
+                    continue;
+                }
+            } else {
+                if let Some(captures) = patch_regex.captures(&line) {
+                    write!(&mut writer, "{}\n", line).unwrap();
+                    let in_path = captures.get(1).unwrap();
+                    patch_marker = Some(
+                        regex::Regex::new(&format!(r"^\s+// END PATCH {}\s*$", in_path.as_str()))
+                            .unwrap(),
+                    );
+                    let in_buff =
+                        BufReader::new(File::open(src_dir.join(in_path.as_str())).unwrap());
+                    write!(
+                        &mut writer,
+                        "    {}\n",
+                        in_buff.lines().flatten().collect::<Vec<_>>().join("\n    ")
+                    )
+                    .unwrap();
+                } else {
+                    write!(&mut writer, "{}\n", line).unwrap();
+                }
+            }
+        }
+    }
+    fs::rename(
+        out_dir.join("grammar_patched.rs"),
+        src_dir.join("grammar.rs"),
+    )
+    .unwrap();
+}
+
+fn build_grammar() {
+    println!("cargo:rerun-if-changed=src/");
+    // let out_path = env::var_os("OUT_DIR").unwrap();
+    // let out_dir = Path::new(&out_path);
+    rust_sitter_tool::build_parsers(&PathBuf::from("src/lib.rs"));
+    // rust_sitter_tool::build_parsers(&out_dir.join("grammar_patched.rs"));
+}
+
+fn main() {
+    let mut logictype_grammar = HashSet::new();
+    let mut enums_grammar = HashSet::new();
+    let mut constants_grammar = HashSet::new();
+    // write_instructions();
+    write_logictypes(&mut logictype_grammar);
+    write_modes(&mut logictype_grammar);
+    write_constants(&mut constants_grammar);
+    write_enums(&mut enums_grammar);
+
+    write_logictypes_grammar(&logictype_grammar);
+    write_enums_grammar(enums_grammar);
+    write_constants_grammar(constants_grammar);
+    write_instructions_grammar();
+
+    patch_grammar();
+
+    build_grammar();
+}
--- a/ic10emu/data/batchmodes.txt
+++ b/ic10emu/data/batchmodes.txt
@@ -0,0 +1,4 @@
+Average 0 Average of all read values
+Sum 1 All read values added together
+Minimum 2 Lowest of all read values
+Maximum 3 Highest of all read values
--- a/ic10emu/data/constants.txt
+++ b/ic10emu/data/constants.txt
@@ -0,0 +1,7 @@
+nan f64::NAN A constant representing 'not a number'. This constants technically provides a 'quiet' NaN, a signal NaN from some instructions will result in an exception and halt execution
+pinf f64::INFINITY A constant representing a positive infinite value
+ninf f64::NEG_INFINITY A constant representing a negative infinite value
+pi 3.14159265358979f64 \nA constant representing the ratio of the circumference of a circle to its diameter, provided in double percision
+deg2rad 0.0174532923847437f64 \nDegrees to radians conversion constant
+rad2deg 57.2957801818848f64 \nRadians to degrees conversion constant
+epsilon f64::EPSILON A constant representing the smallest value representable in double precision
--- a/ic10emu/data/enums.txt
+++ b/ic10emu/data/enums.txt
@@ -0,0 +1,369 @@
+LogicType.Power 1
+LogicType.Open 2
+LogicType.Mode 3
+LogicType.Error 4
+LogicType.Pressure 5
+LogicType.Temperature 6
+LogicType.PressureExternal 7
+LogicType.PressureInternal 8
+LogicType.Activate 9
+LogicType.Lock 10
+LogicType.Charge 11
+LogicType.Setting 12
+LogicType.Reagents 13
+LogicType.RatioOxygen 14
+LogicType.RatioCarbonDioxide 15
+LogicType.RatioNitrogen 16
+LogicType.RatioPollutant 17
+LogicType.RatioVolatiles 18
+LogicType.RatioWater 19
+LogicType.Horizontal 20
+LogicType.Vertical 21
+LogicType.SolarAngle 22
+LogicType.Maximum 23
+LogicType.Ratio 24
+LogicType.PowerPotential 25
+LogicType.PowerActual 26
+LogicType.Quantity 27
+LogicType.On 28
+LogicType.RequiredPower 33
+LogicType.HorizontalRatio 34
+LogicType.VerticalRatio 35
+LogicType.PowerRequired 36
+LogicType.Idle 37
+LogicType.Color 38
+LogicType.ElevatorSpeed 39
+LogicType.ElevatorLevel 40
+LogicType.RecipeHash 41
+LogicType.RequestHash 60
+LogicType.CompletionRatio 61
+LogicType.ClearMemory 62
+LogicType.ExportCount 63
+LogicType.ImportCount 64
+LogicType.PowerGeneration 65
+LogicType.TotalMoles 66
+LogicType.Volume 67
+LogicType.Plant 68
+LogicType.Harvest 69
+LogicType.Output 70
+LogicType.PressureSetting 71
+LogicType.TemperatureSetting 72
+LogicType.TemperatureExternal 73
+LogicType.Filtration 74
+LogicType.AirRelease 75
+LogicType.PositionX 76
+LogicType.PositionZ 78
+LogicType.VelocityMagnitude 79
+LogicType.VelocityRelativeX 80
+LogicType.VelocityRelativeY 81
+LogicType.VelocityRelativeZ 82
+LogicType.RatioNitrousOxide 83
+LogicType.PrefabHash 84
+LogicType.ForceWrite 85
+LogicType.SignalStrength 86
+LogicType.SignalID 87
+LogicType.TargetX 88
+LogicType.TargetY 89
+LogicType.TargetZ 90
+LogicType.SettingInput 91
+LogicType.SettingOutput 92
+LogicType.CurrentResearchPodType 93
+LogicType.ManualResearchRequiredPod 94
+LogicType.MineablesInVicinity 95
+LogicType.MineablesInQueue 96
+LogicType.NextWeatherEventTime 97
+LogicType.Combustion 98
+LogicType.Fuel 99
+LogicType.ReturnFuelCost 100
+LogicType.CollectableGoods 101
+LogicType.Time 102
+LogicType.Bpm 103
+LogicType.EnvironmentEfficiency 104
+LogicType.WorkingGasEfficiency 105
+LogicType.PressureInput 106
+LogicType.TemperatureInput 107
+LogicType.RatioOxygenInput 108
+LogicType.RatioCarbonDioxideInput 109
+LogicType.RatioNitrogenInput 110
+LogicType.RatioPollutantInput 111
+LogicType.RatioVolatilesInput 112
+LogicType.RatioWaterInput 113
+LogicType.RatioNitrousOxideInput 114
+LogicType.TotalMolesInput 115
+LogicType.PressureInput2 116
+LogicType.TemperatureInput2 117
+LogicType.RatioOxygenInput2 118
+LogicType.RatioCarbonDioxideInput2 119
+LogicType.RatioNitrogenInput2 120
+LogicType.RatioPollutantInput2 121
+LogicType.RatioVolatilesInput2 122
+LogicType.RatioWaterInput2 123
+LogicType.RatioNitrousOxideInput2 124
+LogicType.TotalMolesInput2 125
+LogicType.PressureOutput 126
+LogicType.TemperatureOutput 127
+LogicType.RatioOxygenOutput 128
+LogicType.RatioCarbonDioxideOutput 129
+LogicType.RatioNitrogenOutput 130
+LogicType.RatioPollutantOutput 131
+LogicType.RatioVolatilesOutput 132
+LogicType.RatioWaterOutput 133
+LogicType.RatioNitrousOxideOutput 134
+LogicType.TotalMolesOutput 135
+LogicType.PressureOutput2 136
+LogicType.TemperatureOutput2 137
+LogicType.RatioOxygenOutput2 138
+LogicType.RatioCarbonDioxideOutput2 139
+LogicType.RatioNitrogenOutput2 140
+LogicType.RatioPollutantOutput2 141
+LogicType.RatioVolatilesOutput2 142
+LogicType.RatioWaterOutput2 143
+LogicType.RatioNitrousOxideOutput2 144
+LogicType.TotalMolesOutput2 145
+LogicType.CombustionInput 146
+LogicType.CombustionInput2 147
+LogicType.CombustionOutput 148
+LogicType.CombustionOutput2 149
+LogicType.OperationalTemperatureEfficiency 150
+LogicType.TemperatureDifferentialEfficiency 151
+LogicType.PressureEfficiency 152
+LogicType.CombustionLimiter 153
+LogicType.Throttle 154
+LogicType.Rpm 155
+LogicType.Stress 156
+LogicType.InterrogationProgress 157
+LogicType.TargetPadIndex 158
+LogicType.SizeX 160
+LogicType.SizeY 161
+LogicType.SizeZ 162
+LogicType.MinimumWattsToContact 163
+LogicType.WattsReachingContact 164
+LogicType.Channel0 165
+LogicType.Channel1 166
+LogicType.Channel2 167
+LogicType.Channel3 168
+LogicType.Channel4 169
+LogicType.Channel5 170
+LogicType.Channel6 171
+LogicType.Channel7 172
+LogicType.LineNumber 173
+LogicType.Flush 174
+LogicType.SoundAlert 175
+LogicType.SolarIrradiance 176
+LogicType.RatioLiquidNitrogen 177
+LogicType.RatioLiquidNitrogenInput 178
+LogicType.RatioLiquidNitrogenInput2 179
+LogicType.RatioLiquidNitrogenOutput 180
+LogicType.RatioLiquidNitrogenOutput2 181
+LogicType.VolumeOfLiquid 182
+LogicType.RatioLiquidOxygen 183
+LogicType.RatioLiquidOxygenInput 184
+LogicType.RatioLiquidOxygenInput2 185
+LogicType.RatioLiquidOxygenOutput 186
+LogicType.RatioLiquidOxygenOutput2 187
+LogicType.RatioLiquidVolatiles 188
+LogicType.RatioLiquidVolatilesInput 189
+LogicType.RatioLiquidVolatilesInput2 190
+LogicType.RatioLiquidVolatilesOutput 191
+LogicType.RatioLiquidVolatilesOutput2 192
+LogicType.RatioSteam 193
+LogicType.RatioSteamInput 194
+LogicType.RatioSteamInput2 195
+LogicType.RatioSteamOutput 196
+LogicType.RatioSteamOutput2 197
+LogicType.ContactTypeId 198
+LogicType.RatioLiquidCarbonDioxide 199
+LogicType.RatioLiquidCarbonDioxideInput 200
+LogicType.RatioLiquidCarbonDioxideInput2 201
+LogicType.RatioLiquidCarbonDioxideOutput 202
+LogicType.RatioLiquidCarbonDioxideOutput2 203
+LogicType.RatioLiquidPollutant 204
+LogicType.RatioLiquidPollutantInput 205
+LogicType.RatioLiquidPollutantInput2 206
+LogicType.RatioLiquidPollutantOutput 207
+LogicType.RatioLiquidPollutantOutput2 208
+LogicType.RatioLiquidNitrousOxide 209
+LogicType.RatioLiquidNitrousOxideInput 210
+LogicType.RatioLiquidNitrousOxideInput2 211
+LogicType.RatioLiquidNitrousOxideOutput 212
+LogicType.RatioLiquidNitrousOxideOutput2 213
+LogicType.Progress 214
+LogicType.DestinationCode 215
+LogicType.Acceleration 216
+LogicType.ReferenceId 217
+LogicType.AutoShutOff 218
+LogicType.Mass 219
+LogicType.DryMass 220
+LogicType.Thrust 221
+LogicType.Weight 222
+LogicType.ThrustToWeight 223
+LogicType.TimeToDestination 224
+LogicType.BurnTimeRemaining 225
+LogicType.AutoLand 226
+LogicType.ForwardX 227
+LogicType.ForwardY 228
+LogicType.ForwardZ 229
+LogicType.Orientation 230
+LogicType.VelocityX 231
+LogicType.VelocityY 232
+LogicType.VelocityZ 233
+LogicType.PassedMoles 234
+LogicType.ExhaustVelocity 235
+LogicType.FlightControlRule 236
+LogicType.ReEntryAltitude 237
+LogicType.Apex 238
+LogicType.EntityState 239
+LogicType.DrillCondition 240
+LogicType.Index 241
+LogicType.CelestialHash 242
+LogicType.AlignmentError 243
+LogicType.DistanceAu 244
+LogicType.OrbitPeriod 245
+LogicType.Inclination 246
+LogicType.Eccentricity 247
+LogicType.SemiMajorAxis 248
+LogicType.DistanceKm 249
+LogicType.CelestialParentHash 250
+LogicType.TrueAnomaly 251
+
+LogicSlotType.None 0
+LogicSlotType.Occupied 1
+LogicSlotType.OccupantHash 2
+LogicSlotType.Quantity 3
+LogicSlotType.Damage 4
+LogicSlotType.Efficiency 5
+LogicSlotType.Health 6
+LogicSlotType.Growth 7
+LogicSlotType.Pressure 8
+LogicSlotType.Temperature 9
+LogicSlotType.Charge 10
+LogicSlotType.ChargeRatio 11
+LogicSlotType.Class 12
+LogicSlotType.PressureWaste 13
+LogicSlotType.PressureAir 14
+LogicSlotType.MaxQuantity 15
+LogicSlotType.Mature 16
+LogicSlotType.PrefabHash 17
+LogicSlotType.Seeding 18
+LogicSlotType.LineNumber 19
+LogicSlotType.Volume 20
+LogicSlotType.Open 21
+LogicSlotType.On 22
+LogicSlotType.Lock 23
+LogicSlotType.SortingClass 24
+LogicSlotType.FilterType 25
+LogicSlotType.ReferenceId 26
+
+SlotClass.None 0
+SlotClass.Helmet 1
+SlotClass.Suit 2
+SlotClass.Back 3
+SlotClass.GasFilter 4
+SlotClass.Motherboard 6
+SlotClass.Circuitboard 7
+SlotClass.DataDisk 8
+SlotClass.Organ 9
+SlotClass.Ore 10
+SlotClass.Plant 11
+SlotClass.Uniform 12
+SlotClass.Battery 14
+SlotClass.Egg 15
+SlotClass.Belt 16
+SlotClass.Tool 17
+SlotClass.Appliance 18
+SlotClass.Ingot 19
+SlotClass.Torpedo 20
+SlotClass.Cartridge 21
+SlotClass.AccessCard 22
+SlotClass.Magazine 23
+SlotClass.Circuit 24
+SlotClass.Bottle 25
+SlotClass.ProgrammableChip 26
+SlotClass.Glasses 27
+SlotClass.CreditCard 28
+SlotClass.DirtCanister 29
+SlotClass.SensorProcessingUnit 30
+SlotClass.LiquidCanister 31
+SlotClass.LiquidBottle 32
+SlotClass.Wreckage 33
+SlotClass.SoundCartridge 34
+SlotClass.DrillHead 35
+SlotClass.ScanningHead 36
+SlotClass.Flare 37
+SlotClass.Blocked 38
+
+GasType.Undefined 0
+GasType.Oxygen 1
+GasType.Nitrogen 2
+GasType.CarbonDioxide 4
+GasType.Volatiles 8
+GasType.Pollutant 16
+GasType.Water 32
+GasType.NitrousOxide 64
+GasType.LiquidNitrogen 128
+GasType.LiquidVolatiles 512
+GasType.Steam 1024
+GasType.LiquidCarbonDioxide 2048
+GasType.LiquidPollutant 4096
+GasType.LiquidNitrousOxide 8192
+
+AirCon.Cold 0
+AirCon.Hot 1
+AirControl.None 0
+AirControl.Offline 1
+AirControl.Pressure 2
+AirControl.Draught 4
+Color.Blue 0
+Color.Gray 1
+Color.Green 2
+Color.Orange 3
+Color.Red 4
+Color.Yellow 5
+Color.White 6
+Color.Black 7
+Color.Brown 8
+Color.Khaki 9
+Color.Pink 10
+Color.Purple 11
+DaylightSensorMode.Default 0
+DaylightSensorMode.Horizontal 1
+DaylightSensorMode.Vertical 2
+ElevatorMode.Stationary 0
+ElevatorMode.Upward 1
+ElevatorMode.Downward 2
+EntityState.Alive 0
+EntityState.Dead 1
+EntityState.Unconscious 2
+EntityState.Decay 3
+PowerMode.Idle 0
+PowerMode.Discharged 1
+PowerMode.Discharging 2
+PowerMode.Charging 3
+PowerMode.Charged 4
+RobotMode.None 0
+RobotMode.Follow 1
+RobotMode.MoveToTarget 2
+RobotMode.Roam 3
+RobotMode.Unload 4
+RobotMode.PathToTarget 5
+RobotMode.StorageFull 6
+SortingClass.Default 0
+SortingClass.Kits 1
+SortingClass.Tools 2
+SortingClass.Resources 3
+SortingClass.Food 4
+SortingClass.Clothing 5
+SortingClass.Appliances 6
+SortingClass.Atmospherics 7
+SortingClass.Storage 8
+SortingClass.Ores 9
+SortingClass.Ices 10
+TransmitterMode.Passive 0
+TransmitterMode.Active 1
+Vent.Outward 0
+Vent.Inward 1
+
+Equals 0
+Greater 1
+Less 2
+NotEquals 3
--- a/ic10emu/data/instructions.txt
+++ b/ic10emu/data/instructions.txt
@@ -0,0 +1,141 @@
+abs REGISTER VALUE
+acos REGISTER VALUE
+add REGISTER VALUE VALUE
+alias NAME REGISTER_DEVICE
+and REGISTER VALUE VALUE
+asin REGISTER VALUE
+atan REGISTER VALUE
+atan2 REGISTER VALUE VALUE
+bap VALUE VALUE VALUE VALUE
+bapal VALUE VALUE VALUE VALUE
+bapz VALUE VALUE VALUE
+bapzal VALUE VALUE VALUE
+bdns DEVICE VALUE
+bdnsal DEVICE VALUE
+bdse DEVICE VALUE
+bdseal DEVICE VALUE
+beq VALUE VALUE VALUE
+beqal VALUE VALUE VALUE
+beqz VALUE VALUE
+beqzal VALUE VALUE
+bge VALUE VALUE VALUE
+bgeal VALUE VALUE VALUE
+bgez VALUE VALUE
+bgezal VALUE VALUE
+bgt VALUE VALUE VALUE
+bgtal VALUE VALUE VALUE
+bgtz VALUE VALUE
+bgtzal VALUE VALUE
+ble VALUE VALUE VALUE
+bleal VALUE VALUE VALUE
+blez VALUE VALUE
+blezal VALUE VALUE
+blt VALUE VALUE VALUE
+bltal VALUE VALUE VALUE
+bltz VALUE VALUE
+bltzal VALUE VALUE
+bna VALUE VALUE VALUE VALUE
+bnaal VALUE VALUE VALUE VALUE
+bnan VALUE VALUE
+bnaz VALUE VALUE VALUE
+bnazal VALUE VALUE VALUE
+bne VALUE VALUE VALUE
+bneal VALUE VALUE VALUE
+bnez VALUE VALUE
+bnezal VALUE VALUE
+brap VALUE VALUE VALUE VALUE
+brapz VALUE VALUE VALUE
+brdns DEVICE VALUE
+brdse DEVICE VALUE
+breq VALUE VALUE VALUE
+breqz VALUE VALUE
+brge VALUE VALUE VALUE
+brgez VALUE VALUE
+brgt VALUE VALUE VALUE
+brgtz VALUE VALUE
+brle VALUE VALUE VALUE
+brlez VALUE VALUE
+brlt VALUE VALUE VALUE
+brltz VALUE VALUE
+brna VALUE VALUE VALUE VALUE
+brnan VALUE VALUE
+brnaz VALUE VALUE VALUE
+brne VALUE VALUE VALUE
+brnez VALUE VALUE
+ceil REGISTER VALUE
+cos REGISTER VALUE
+define NAME NUMBER
+div REGISTER VALUE VALUE
+exp REGISTER VALUE
+floor REGISTER VALUE
+get REGISTER DEVICE ADDRESS
+getd REGISTER DEVICE_ID ADDRESS
+hcf
+j VALUE
+jal VALUE
+jr VALUE
+l REGISTER DEVICE LOGIC_TYPE
+label NAME REGISTER_DEVICE
+lb REGISTER DEVICE_TYPE LOGIC_TYPE BATCH_MODE
+lbn REGISTER DEVICE_TYPE DEVICE_NAME LOGIC_TYPE BATCH_MODE
+lbns REGISTER DEVICE_TYPE DEVICE_NAME INDEX SLOT_LOGIC_TYPE BATCH_MODE
+lbs REGISTER DEVICE_TYPE INDEX SLOT_LOGIC_TYPE BATCH_MODE
+ld REGISTER DEVICE_ID LOGIC_TYPE
+log REGISTER VALUE
+lr REGISTER DEVICE REAGENT_MODE VALUE
+ls REGISTER DEVICE VALUE SLOT_LOGIC_TYPE
+max REGISTER VALUE VALUE
+min REGISTER VALUE VALUE
+mod REGISTER VALUE VALUE
+move REGISTER VALUE
+mul REGISTER VALUE VALUE
+nor REGISTER VALUE VALUE
+not REGISTER VALUE
+or REGISTER VALUE VALUE
+peek REGISTER
+poke ADDRESS VALUE
+pop REGISTER
+push VALUE
+put DEVICE ADDRESS VALUE
+putd DEVICE_ID ADDRESS VALUE
+rand REGISTER
+round REGISTER VALUE
+s DEVICE LOGIC_TYPE VALUE
+sap REGISTER VALUE VALUE VALUE
+sapz REGISTER VALUE VALUE
+sb DEVICE_TYPE LOGIC_TYPE VALUE
+sbn DEVICE_TYPE DEVICE_NAME LOGIC_TYPE VALUE
+sbs DEVICE_TYPE INDEX SLOT_LOGIC_TYPE VALUE
+sd DEVICE_ID LOGIC_TYPE VALUE
+sdns REGISTER DEVICE
+sdse REGISTER DEVICE
+select REGISTER VALUE VALUE VALUE
+seq REGISTER VALUE VALUE
+seqz REGISTER VALUE
+sge REGISTER VALUE VALUE
+sgez REGISTER VALUE
+sgt REGISTER VALUE VALUE
+sgtz REGISTER VALUE
+sin REGISTER VALUE
+sla REGISTER VALUE VALUE
+sle REGISTER VALUE VALUE
+sleep VALUE
+slez REGISTER VALUE
+sll REGISTER VALUE VALUE
+slt REGISTER VALUE VALUE
+sltz REGISTER VALUE
+sna REGISTER VALUE VALUE VALUE
+snan REGISTER VALUE
+snanz REGISTER VALUE
+snaz REGISTER VALUE VALUE
+sne REGISTER VALUE VALUE
+snez REGISTER VALUE
+sqrt REGISTER VALUE
+sra REGISTER VALUE VALUE
+srl REGISTER VALUE VALUE
+ss DEVICE VALUE SLOT_LOGIC_TYPE REGISTER
+sub REGISTER VALUE VALUE
+tan REGISTER VALUE
+trunc REGISTER VALUE
+xor REGISTER VALUE VALUE
+yield
--- a/ic10emu/data/logictypes.txt
+++ b/ic10emu/data/logictypes.txt
@@ -0,0 +1,259 @@
+Acceleration 216 Change in velocity. Rockets that are deccelerating when landing will show this as negative value.
+Activate 9 1 if device is activated (usually means running), otherwise 0
+AirRelease 75 The current state of the air release system, for example AirRelease = 1 for a Hardsuit sets Air Release to On
+AlignmentError 243 
+Apex 238 
+AutoLand 226 Engages the automatic landing algorithm. The rocket will automatically throttle and turn on and off its engines to achieve a smooth landing.
+AutoShutOff 218 Turns off all devices in the rocket upon reaching destination
+Bpm 103 Bpm
+BurnTimeRemaining 225 Estimated time in seconds until fuel is depleted. Calculated based on current fuel usage.
+Bypass None Bypasses some internal behavoiur of the atmospherics device.
+CelestialHash 242 
+CelestialParentHash 250 
+Channel None Channel on a cable network which should be considered volatile
+Channel0 165 
+Channel1 166 
+Channel2 167 
+Channel3 168 
+Channel4 169 
+Channel5 170 
+Channel6 171 
+Channel7 172 
+Charge 11 The current charge the device has
+ClearMemory 62 When set to 1, clears the counter memory (e.g. ExportCount). Will set itself back to 0 when actioned
+CollectableGoods 101 
+Color 38 \n        Whether driven by concerns for clarity, safety or simple aesthetics, {LINK:Stationeers;Stationeers} have access to a small rainbow of colors for their constructions. These are the color setting for devices, represented as an integer.\n\n0: Blue\n1: Grey\n2: Green\n3: Orange\n4: Red\n5: Yellow\n6: White\n7: Black\n8: Brown\n9: Khaki\n10: Pink\n11: Purple\n\n        It is an unwavering universal law that anything higher than 11 will be purple. The {LINK:ODA;ODA} is powerless to change this. Similarly, anything lower than 0 will be Blue.\n      
+Combustion 98 The assess atmosphere is on fire. Returns 1 if atmosphere is on fire, 0 if not.
+CombustionInput 146 The assess atmosphere is on fire. Returns 1 if device's input network is on fire, 0 if not.
+CombustionInput2 147 The assess atmosphere is on fire. Returns 1 if device's Input2 network is on fire, 0 if not.
+CombustionLimiter 153 Retards the rate of combustion inside the machine (range: 0-100), with 0 being the slowest rate of combustion and 100 being the fastest
+CombustionOutput 148 The assess atmosphere is on fire. Returns 1 if device's Output network is on fire, 0 if not.
+CombustionOutput2 149 The assess atmosphere is on fire. Returns 1 if device's Output2 network is on fire, 0 if not.
+CompletionRatio 61 How complete the current production is for this device, between 0 and 1
+ContactTypeId 198 The type id of the contact.
+CurrentResearchPodType 93 
+DestinationCode 215 Unique identifier code for a destination on the space map.
+DistanceAu 244 
+DistanceKm 249 
+DrillCondition 240 
+DryMass 220 The Mass in kilograms of the rocket excluding fuel. The more massive the rocket the more fuel will be required to move to a new location in space.
+Eccentricity 247 
+ElevatorLevel 40 Level the elevator is currently at
+ElevatorSpeed 39 Current speed of the elevator
+EntityState 239 
+EnvironmentEfficiency 104 The Environment Efficiency reported by the machine, as a float between 0 and 1
+Error 4 1 if device is in error state, otherwise 0
+ExhaustVelocity 235 
+ExportCount 63 How many items exported since last ClearMemory
+ExportQuantity None Total quantity of items exported by the device
+ExportSlotHash None DEPRECATED
+ExportSlotOccupant None DEPRECATED
+Filtration 74 The current state of the filtration system, for example Filtration = 1 for a Hardsuit sets filtration to On
+FlightControlRule 236 
+Flush 174 Set to 1 to activate the flush function on the device
+ForceWrite 85 Forces Logic Writer devices to rewrite value
+ForwardX 227 
+ForwardY 228 
+ForwardZ 229 
+Fuel 99 
+Harvest 69 Performs the harvesting action for any plant based machinery
+Horizontal 20 Horizontal setting of the device
+HorizontalRatio 34 Radio of horizontal setting for device
+Idle 37 Returns 1 if the device is currently idle, otherwise 0
+ImportCount 64 How many items imported since last ClearMemory
+ImportQuantity None Total quantity of items imported by the device
+ImportSlotHash None DEPRECATED
+ImportSlotOccupant None DEPRECATED
+Inclination 246 
+Index 241 
+InterrogationProgress 157 Progress of this sattellite dish's interrogation of its current target, as a ratio from 0-1
+LineNumber 173 The line number of current execution for an integrated circuit running on this device. While this number can be written, use with caution
+Lock 10 1 if device is locked, otherwise 0, can be set in most devices and prevents the user from access the values
+ManualResearchRequiredPod 94 
+Mass 219 The total Mass of the rocket in kilograms including fuel and cargo. The more massive the rocket the more fuel will be required to move to a new location in space.
+Maximum 23 Maximum setting of the device
+MinWattsToContact None Minimum required amount of watts from the dish hitting the target trader contact to start interrogating the contact
+MineablesInQueue 96 
+MineablesInVicinity 95 
+MinimumWattsToContact 163 
+Mode 3 Integer for mode state, different devices will have different mode states available to them
+NextWeatherEventTime 97 
+None None No description
+On 28 The current state of the device, 0 for off, 1 for on
+Open 2 1 if device is open, otherwise 0
+OperationalTemperatureEfficiency 150 How the input pipe's temperature effects the machines efficiency
+OrbitPeriod 245 
+Orientation 230 
+Output 70 The output operation for a sort handling device, such as a stacker or sorter, when in logic mode the device will only action one repetition when set zero or above and then back to -1 and await further instructions
+OverShootTarget None How far is the landing rocket going to overshoot its landing target at its current thrust. Expressed as a negative value in meters. ensure this is at zero by the time a rocket lands or risk total loss of rocket.
+PassedMoles 234 
+Plant 68 Performs the planting action for any plant based machinery
+PlantEfficiency1 None DEPRECATED
+PlantEfficiency2 None DEPRECATED
+PlantEfficiency3 None DEPRECATED
+PlantEfficiency4 None DEPRECATED
+PlantGrowth1 None DEPRECATED
+PlantGrowth2 None DEPRECATED
+PlantGrowth3 None DEPRECATED
+PlantGrowth4 None DEPRECATED
+PlantHash1 None DEPRECATED
+PlantHash2 None DEPRECATED
+PlantHash3 None DEPRECATED
+PlantHash4 None DEPRECATED
+PlantHealth1 None DEPRECATED
+PlantHealth2 None DEPRECATED
+PlantHealth3 None DEPRECATED
+PlantHealth4 None DEPRECATED
+PositionX 76 The current position in X dimension in world coordinates
+PositionY None The current position in Y dimension in world coordinates
+PositionZ 78 The current position in Z dimension in world coordinates
+Power 1 Can be read to return if the device is correctly powered or not, set via the power system, return 1 if powered and 0 if not
+PowerActual 26 How much energy the device or network is actually using
+PowerGeneration 65 Returns how much power is being generated
+PowerPotential 25 How much energy the device or network potentially provides
+PowerRequired 36 Power requested from the device and/or network
+PrefabHash 84 The hash of the structure
+Pressure 5 The current pressure reading of the device
+PressureEfficiency 152 How the pressure of the input pipe and waste pipe effect the machines efficiency
+PressureExternal 7 Setting for external pressure safety, in KPa
+PressureInput 106 The current pressure reading of the device's Input Network
+PressureInput2 116 The current pressure reading of the device's Input2 Network
+PressureInternal 8 Setting for internal pressure safety, in KPa
+PressureOutput 126 The current pressure reading of the device's Output Network
+PressureOutput2 136 The current pressure reading of the device's Output2 Network
+PressureSetting 71 The current setting for the internal pressure of the object (e.g. the Hardsuit Air release), in KPa
+Progress 214 Progress of the rocket to the next node on the map expressed as a value between 0-1.
+Quantity 27 Total quantity on the device
+Ratio 24 Context specific value depending on device, 0 to 1 based ratio
+RatioCarbonDioxide 15 The ratio of {GAS:CarbonDioxide} in device atmosphere
+RatioCarbonDioxideInput 109 The ratio of {GAS:CarbonDioxide} in device's input network
+RatioCarbonDioxideInput2 119 The ratio of {GAS:CarbonDioxide} in device's Input2 network
+RatioCarbonDioxideOutput 129 The ratio of {GAS:CarbonDioxide} in device's Output network
+RatioCarbonDioxideOutput2 139 The ratio of {GAS:CarbonDioxide} in device's Output2 network
+RatioLiquidCarbonDioxide 199 The ratio of {GAS:LiquidCarbonDioxide} in device's Atmosphere
+RatioLiquidCarbonDioxideInput 200 The ratio of {GAS:LiquidCarbonDioxide} in device's Input Atmosphere
+RatioLiquidCarbonDioxideInput2 201 The ratio of {GAS:LiquidCarbonDioxide} in device's Input2 Atmosphere
+RatioLiquidCarbonDioxideOutput 202 The ratio of {GAS:LiquidCarbonDioxide} in device's device's Output Atmosphere
+RatioLiquidCarbonDioxideOutput2 203 The ratio of {GAS:LiquidCarbonDioxide} in device's Output2 Atmopshere
+RatioLiquidNitrogen 177 The ratio of {GAS:LiquidNitrogen} in device atmosphere
+RatioLiquidNitrogenInput 178 The ratio of {GAS:LiquidNitrogen} in device's input network
+RatioLiquidNitrogenInput2 179 The ratio of {GAS:LiquidNitrogen} in device's Input2 network
+RatioLiquidNitrogenOutput 180 The ratio of {GAS:LiquidNitrogen} in device's Output network
+RatioLiquidNitrogenOutput2 181 The ratio of {GAS:LiquidNitrogen} in device's Output2 network
+RatioLiquidNitrousOxide 209 The ratio of {GAS:LiquidNitrousOxide} in device's Atmosphere
+RatioLiquidNitrousOxideInput 210 The ratio of {GAS:LiquidNitrousOxide} in device's Input Atmosphere
+RatioLiquidNitrousOxideInput2 211 The ratio of {GAS:LiquidNitrousOxide} in device's Input2 Atmosphere
+RatioLiquidNitrousOxideOutput 212 The ratio of {GAS:LiquidNitrousOxide} in device's device's Output Atmosphere
+RatioLiquidNitrousOxideOutput2 213 The ratio of {GAS:LiquidNitrousOxide} in device's Output2 Atmopshere
+RatioLiquidOxygen 183 The ratio of {GAS:LiquidOxygen} in device's Atmosphere
+RatioLiquidOxygenInput 184 The ratio of {GAS:LiquidOxygen} in device's Input Atmosphere
+RatioLiquidOxygenInput2 185 The ratio of {GAS:LiquidOxygen} in device's Input2 Atmosphere
+RatioLiquidOxygenOutput 186 The ratio of {GAS:LiquidOxygen} in device's device's Output Atmosphere
+RatioLiquidOxygenOutput2 187 The ratio of {GAS:LiquidOxygen} in device's Output2 Atmopshere
+RatioLiquidPollutant 204 The ratio of {GAS:LiquidPollutant} in device's Atmosphere
+RatioLiquidPollutantInput 205 The ratio of {GAS:LiquidPollutant} in device's Input Atmosphere
+RatioLiquidPollutantInput2 206 The ratio of {GAS:LiquidPollutant} in device's Input2 Atmosphere
+RatioLiquidPollutantOutput 207 The ratio of {GAS:LiquidPollutant} in device's device's Output Atmosphere
+RatioLiquidPollutantOutput2 208 The ratio of {GAS:LiquidPollutant} in device's Output2 Atmopshere
+RatioLiquidVolatiles 188 The ratio of {GAS:LiquidVolatiles} in device's Atmosphere
+RatioLiquidVolatilesInput 189 The ratio of {GAS:LiquidVolatiles} in device's Input Atmosphere
+RatioLiquidVolatilesInput2 190 The ratio of {GAS:LiquidVolatiles} in device's Input2 Atmosphere
+RatioLiquidVolatilesOutput 191 The ratio of {GAS:LiquidVolatiles} in device's device's Output Atmosphere
+RatioLiquidVolatilesOutput2 192 The ratio of {GAS:LiquidVolatiles} in device's Output2 Atmopshere
+RatioNitrogen 16 The ratio of nitrogen in device atmosphere
+RatioNitrogenInput 110 The ratio of nitrogen in device's input network
+RatioNitrogenInput2 120 The ratio of nitrogen in device's Input2 network
+RatioNitrogenOutput 130 The ratio of nitrogen in device's Output network
+RatioNitrogenOutput2 140 The ratio of nitrogen in device's Output2 network
+RatioNitrousOxide 83 The ratio of {GAS:NitrousOxide} in device atmosphere
+RatioNitrousOxideInput 114 The ratio of {GAS:NitrousOxide} in device's input network
+RatioNitrousOxideInput2 124 The ratio of {GAS:NitrousOxide} in device's Input2 network
+RatioNitrousOxideOutput 134 The ratio of {GAS:NitrousOxide} in device's Output network
+RatioNitrousOxideOutput2 144 The ratio of {GAS:NitrousOxide} in device's Output2 network
+RatioOxygen 14 The ratio of oxygen in device atmosphere
+RatioOxygenInput 108 The ratio of oxygen in device's input network
+RatioOxygenInput2 118 The ratio of oxygen in device's Input2 network
+RatioOxygenOutput 128 The ratio of oxygen in device's Output network
+RatioOxygenOutput2 138 The ratio of oxygen in device's Output2 network
+RatioPollutant 17 The ratio of pollutant in device atmosphere
+RatioPollutantInput 111 The ratio of pollutant in device's input network
+RatioPollutantInput2 121 The ratio of pollutant in device's Input2 network
+RatioPollutantOutput 131 The ratio of pollutant in device's Output network
+RatioPollutantOutput2 141 The ratio of pollutant in device's Output2 network
+RatioSteam 193 The ratio of {GAS:Steam} in device's Atmosphere
+RatioSteamInput 194 The ratio of {GAS:Steam} in device's Input Atmosphere
+RatioSteamInput2 195 The ratio of {GAS:Steam} in device's Input2 Atmosphere
+RatioSteamOutput 196 The ratio of {GAS:Steam} in device's device's Output Atmosphere
+RatioSteamOutput2 197 The ratio of {GAS:Steam} in device's Output2 Atmopshere
+RatioVolatiles 18 The ratio of volatiles in device atmosphere
+RatioVolatilesInput 112 The ratio of volatiles in device's input network
+RatioVolatilesInput2 122 The ratio of volatiles in device's Input2 network
+RatioVolatilesOutput 132 The ratio of volatiles in device's Output network
+RatioVolatilesOutput2 142 The ratio of volatiles in device's Output2 network
+RatioWater 19 The ratio of water in device atmosphere
+RatioWaterInput 113 The ratio of water in device's input network
+RatioWaterInput2 123 The ratio of water in device's Input2 network
+RatioWaterOutput 133 The ratio of water in device's Output network
+RatioWaterOutput2 143 The ratio of water in device's Output2 network
+ReEntryAltitude 237 
+Reagents 13 Total number of reagents recorded by the device
+RecipeHash 41 Current hash of the recipe the device is set to produce
+ReferenceId 217 
+RequestHash 60 When set to the unique identifier, requests an item of the provided type from the device
+RequiredPower 33 Idle operating power quantity, does not necessarily include extra demand power
+ReturnFuelCost 100 
+Rpm 155 The number of revolutions per minute that the device's spinning mechanism is doing
+SemiMajorAxis 248 
+Setting 12 A variable setting that can be read or written, depending on the device
+SettingInput 91 
+SettingInputHash None The input setting for the device
+SettingOutput 92 
+SettingOutputHash None The output setting for the device
+SignalID 87 Returns the contact ID of the strongest signal from this Satellite
+SignalStrength 86 Returns the degree offset of the strongest contact
+SizeX 160 Size on the X (right) axis of the object in largeGrids (a largeGrid is 2meters)
+SizeY 161 Size on the Y(Up) axis of the object in largeGrids (a largeGrid is 2meters)
+SizeZ 162 Size on the Z(Forward) axis of the object in largeGrids (a largeGrid is 2meters)
+SolarAngle 22 Solar angle of the device
+SolarConstant None Solar constant of the world
+SolarIrradiance 176 
+SoundAlert 175 Plays a sound alert on the devices speaker
+Stress 156 Machines get stressed when working hard. When Stress reaches 100 the machine will automatically shut down
+TargetPadIndex 158 The index of the trader landing pad on this devices data network that it will try to call a trader in to land
+TargetX 88 The target position in X dimension in world coordinates
+TargetY 89 The target position in Y dimension in world coordinates
+TargetZ 90 The target position in Z dimension in world coordinates
+Temperature 6 The current temperature reading of the device
+TemperatureDifferentialEfficiency 151 How the difference between the input pipe and waste pipe temperatures effect the machines efficiency
+TemperatureExternal 73 The temperature of the outside of the device, usually the world atmosphere surrounding it
+TemperatureInput 107 The current temperature reading of the device's Input Network
+TemperatureInput2 117 The current temperature reading of the device's Input2 Network
+TemperatureOutput 127 The current temperature reading of the device's Output Network
+TemperatureOutput2 137 The current temperature reading of the device's Output2 Network
+TemperatureSetting 72 The current setting for the internal temperature of the object (e.g. the Hardsuit A/C)
+Throttle 154 Increases the rate at which the machine works (range: 0-100)
+Thrust 221 Total current thrust of all rocket engines on the rocket in Newtons.
+ThrustToWeight 223 Ratio of thrust to weight of rocket. Weight is effected by local body gravity. A rocket with a low thrust to weight will expend more fuel during launch and landing.
+Time 102 Time
+TimeToDestination 224 Estimated time in seconds until rocket arrives at target destination.
+TotalMoles 66 Returns the total moles of the device
+TotalMolesInput 115 Returns the total moles of the device's Input Network
+TotalMolesInput2 125 Returns the total moles of the device's Input2 Network
+TotalMolesOutput 135 Returns the total moles of the device's Output Network
+TotalMolesOutput2 145 Returns the total moles of the device's Output2 Network
+TrueAnomaly 251 
+Unknown None No description available
+VelocityMagnitude 79 The current magnitude of the velocity vector
+VelocityRelativeX 80 The current velocity X relative to the forward vector of this
+VelocityRelativeY 81 The current velocity Y relative to the forward vector of this
+VelocityRelativeZ 82 The current velocity Z relative to the forward vector of this
+VelocityX 231 
+VelocityY 232 
+VelocityZ 233 
+Vertical 21 Vertical setting of the device
+VerticalRatio 35 Radio of vertical setting for device
+Volume 67 Returns the device atmosphere volume
+VolumeOfLiquid 182 The total volume of all liquids in Liters in the atmosphere
+WattsReachingContact 164 The amount of watts actually hitting the contact. This is effected by the power of the dish and how far off-axis the dish is from the contact vector
+Weight 222 Weight of Rocket in Newtons (Including fuel and cargo). Weight is effected by local body gravity.
+WorkingGasEfficiency 105 The Working Gas Efficiency reported by the machine, as a float between 0 and 1
--- a/ic10emu/data/reagentmodes.txt
+++ b/ic10emu/data/reagentmodes.txt
@@ -0,0 +1,3 @@
+Contents 0 The amount of this Reagent present in the machine
+Required 1 The amount of this Reagent needed to complete the Machine's current recipe after subtracting the amount currently present
+Recipe 2 The amount of this Reagent required by the Machine's current recipe
--- a/ic10emu/data/slotlogictypes.txt
+++ b/ic10emu/data/slotlogictypes.txt
@@ -0,0 +1,27 @@
+Charge 10 returns current energy charge the slot occupant is holding
+ChargeRatio 11 returns current energy charge the slot occupant is holding as a ratio between 0 and 1 of its maximum
+Class 12 returns integer representing the class of object
+Damage 4 returns the damage state of the item in the slot
+Efficiency 5 returns the growth efficiency of the plant in the slot
+FilterType 25 
+Growth 7 returns the current growth state of the plant in the slot
+Health 6 returns the health of the plant in the slot
+LineNumber 19 
+Lock 23 
+Mature 16 returns 1 if the plant in this slot is mature, 0 when it isn't
+MaxQuantity 15 returns the max stack size of the item in the slot
+None 0 No description
+OccupantHash 2 returns the has of the current occupant, the unique identifier of the thing
+Occupied 1 returns 0 when slot is not occupied, 1 when it is
+On 22 
+Open 21 
+PrefabHash 17 returns the hash of the structure in the slot
+Pressure 8 returns pressure of the slot occupants internal atmosphere
+PressureAir 14 returns pressure in the air tank of the jetpack in this slot
+PressureWaste 13 returns pressure in the waste tank of the jetpack in this slot
+Quantity 3 returns the current quantity, such as stack size, of the item in the slot
+ReferenceId 26 
+Seeding 18 Whether a plant is seeding (ready to harvest seeds from). Returns 1 if seeding or 0 if not.
+SortingClass 24 
+Temperature 9 returns temperature of the slot occupants internal atmosphere
+Volume 20 
--- a/ic10emu/src/compiler.rs
+++ b/ic10emu/src/compiler.rs
@@ -0,0 +1,5 @@
+
+include!(concat!(env!("OUT_DIR"), "/logictypes.rs"));
+include!(concat!(env!("OUT_DIR"), "/modes.rs"));
+include!(concat!(env!("OUT_DIR"), "/constants.rs"));
+include!(concat!(env!("OUT_DIR"), "/enums.rs"));
--- a/ic10emu/src/grammar.rs
+++ b/ic10emu/src/grammar.rs
--- a/ic10emu/src/grammar/ic10/constants.rs
+++ b/ic10emu/src/grammar/ic10/constants.rs
@@ -0,0 +1,11 @@
+// GENERATED CODE DO NOT MODIFY
+#[derive(PartialEq, Debug)]
+pub enum Constant {
+     Nan( #[rust_sitter::leaf(text = "nan", transform = |s| s.to_string() )] String ),
+     Pi( #[rust_sitter::leaf(text = "pi", transform = |s| s.to_string() )] String ),
+     Pinf( #[rust_sitter::leaf(text = "pinf", transform = |s| s.to_string() )] String ),
+     Rad2Deg( #[rust_sitter::leaf(text = "rad2deg", transform = |s| s.to_string() )] String ),
+     Deg2Rad( #[rust_sitter::leaf(text = "deg2rad", transform = |s| s.to_string() )] String ),
+     Ninf( #[rust_sitter::leaf(text = "ninf", transform = |s| s.to_string() )] String ),
+     Epsilon( #[rust_sitter::leaf(text = "epsilon", transform = |s| s.to_string() )] String ),
+}
--- a/ic10emu/src/grammar/ic10/enums.rs
+++ b/ic10emu/src/grammar/ic10/enums.rs
@@ -0,0 +1,368 @@
+// GENERATED CODE DO NOT MODIFY
+#[derive(PartialEq, Debug)]
+pub enum Enum {
+     LogicSlotTypePressure( #[rust_sitter::leaf(text = "LogicSlotType.Pressure", transform = |s| s.to_string() )] String ),
+     LogicTypeOperationalTemperatureEfficiency( #[rust_sitter::leaf(text = "LogicType.OperationalTemperatureEfficiency", transform = |s| s.to_string() )] String ),
+     SlotClassOrgan( #[rust_sitter::leaf(text = "SlotClass.Organ", transform = |s| s.to_string() )] String ),
+     SlotClassDrillHead( #[rust_sitter::leaf(text = "SlotClass.DrillHead", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioCarbonDioxide( #[rust_sitter::leaf(text = "LogicType.RatioCarbonDioxide", transform = |s| s.to_string() )] String ),
+     LogicTypeInclination( #[rust_sitter::leaf(text = "LogicType.Inclination", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioOxygenOutput2( #[rust_sitter::leaf(text = "LogicType.RatioOxygenOutput2", transform = |s| s.to_string() )] String ),
+     ColorGreen( #[rust_sitter::leaf(text = "Color.Green", transform = |s| s.to_string() )] String ),
+     SlotClassMotherboard( #[rust_sitter::leaf(text = "SlotClass.Motherboard", transform = |s| s.to_string() )] String ),
+     LogicTypeSemiMajorAxis( #[rust_sitter::leaf(text = "LogicType.SemiMajorAxis", transform = |s| s.to_string() )] String ),
+     LogicTypeCharge( #[rust_sitter::leaf(text = "LogicType.Charge", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioSteamInput( #[rust_sitter::leaf(text = "LogicType.RatioSteamInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioSteamOutput2( #[rust_sitter::leaf(text = "LogicType.RatioSteamOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypePassedMoles( #[rust_sitter::leaf(text = "LogicType.PassedMoles", transform = |s| s.to_string() )] String ),
+     LogicTypeEccentricity( #[rust_sitter::leaf(text = "LogicType.Eccentricity", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidOxygen( #[rust_sitter::leaf(text = "LogicType.RatioLiquidOxygen", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeLineNumber( #[rust_sitter::leaf(text = "LogicSlotType.LineNumber", transform = |s| s.to_string() )] String ),
+     RobotModeFollow( #[rust_sitter::leaf(text = "RobotMode.Follow", transform = |s| s.to_string() )] String ),
+     ColorPink( #[rust_sitter::leaf(text = "Color.Pink", transform = |s| s.to_string() )] String ),
+     Equals( #[rust_sitter::leaf(text = "Equals", transform = |s| s.to_string() )] String ),
+     SortingClassAtmospherics( #[rust_sitter::leaf(text = "SortingClass.Atmospherics", transform = |s| s.to_string() )] String ),
+     PowerModeCharging( #[rust_sitter::leaf(text = "PowerMode.Charging", transform = |s| s.to_string() )] String ),
+     SlotClassGasFilter( #[rust_sitter::leaf(text = "SlotClass.GasFilter", transform = |s| s.to_string() )] String ),
+     ColorBrown( #[rust_sitter::leaf(text = "Color.Brown", transform = |s| s.to_string() )] String ),
+     LogicTypeHorizontalRatio( #[rust_sitter::leaf(text = "LogicType.HorizontalRatio", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrogenInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrogenInput2", transform = |s| s.to_string() )] String ),
+     LogicTypePlant( #[rust_sitter::leaf(text = "LogicType.Plant", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustionInput2( #[rust_sitter::leaf(text = "LogicType.CombustionInput2", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeFilterType( #[rust_sitter::leaf(text = "LogicSlotType.FilterType", transform = |s| s.to_string() )] String ),
+     LogicTypePowerPotential( #[rust_sitter::leaf(text = "LogicType.PowerPotential", transform = |s| s.to_string() )] String ),
+     LogicTypeOn( #[rust_sitter::leaf(text = "LogicType.On", transform = |s| s.to_string() )] String ),
+     GasTypePollutant( #[rust_sitter::leaf(text = "GasType.Pollutant", transform = |s| s.to_string() )] String ),
+     GasTypeNitrogen( #[rust_sitter::leaf(text = "GasType.Nitrogen", transform = |s| s.to_string() )] String ),
+     LogicTypeVerticalRatio( #[rust_sitter::leaf(text = "LogicType.VerticalRatio", transform = |s| s.to_string() )] String ),
+     AirConCold( #[rust_sitter::leaf(text = "AirCon.Cold", transform = |s| s.to_string() )] String ),
+     LogicTypeEnvironmentEfficiency( #[rust_sitter::leaf(text = "LogicType.EnvironmentEfficiency", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioPollutantOutput( #[rust_sitter::leaf(text = "LogicType.RatioPollutantOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioVolatilesOutput2( #[rust_sitter::leaf(text = "LogicType.RatioVolatilesOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeLineNumber( #[rust_sitter::leaf(text = "LogicType.LineNumber", transform = |s| s.to_string() )] String ),
+     LogicTypeCelestialParentHash( #[rust_sitter::leaf(text = "LogicType.CelestialParentHash", transform = |s| s.to_string() )] String ),
+     LogicTypeStress( #[rust_sitter::leaf(text = "LogicType.Stress", transform = |s| s.to_string() )] String ),
+     SlotClassProgrammableChip( #[rust_sitter::leaf(text = "SlotClass.ProgrammableChip", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioVolatilesInput( #[rust_sitter::leaf(text = "LogicType.RatioVolatilesInput", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureOutput2( #[rust_sitter::leaf(text = "LogicType.TemperatureOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeMinimumWattsToContact( #[rust_sitter::leaf(text = "LogicType.MinimumWattsToContact", transform = |s| s.to_string() )] String ),
+     GasTypeUndefined( #[rust_sitter::leaf(text = "GasType.Undefined", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeOccupantHash( #[rust_sitter::leaf(text = "LogicSlotType.OccupantHash", transform = |s| s.to_string() )] String ),
+     GasTypeVolatiles( #[rust_sitter::leaf(text = "GasType.Volatiles", transform = |s| s.to_string() )] String ),
+     AirConHot( #[rust_sitter::leaf(text = "AirCon.Hot", transform = |s| s.to_string() )] String ),
+     AirControlNone( #[rust_sitter::leaf(text = "AirControl.None", transform = |s| s.to_string() )] String ),
+     AirControlDraught( #[rust_sitter::leaf(text = "AirControl.Draught", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioWaterInput2( #[rust_sitter::leaf(text = "LogicType.RatioWaterInput2", transform = |s| s.to_string() )] String ),
+     EntityStateAlive( #[rust_sitter::leaf(text = "EntityState.Alive", transform = |s| s.to_string() )] String ),
+     LogicTypeColor( #[rust_sitter::leaf(text = "LogicType.Color", transform = |s| s.to_string() )] String ),
+     SlotClassSensorProcessingUnit( #[rust_sitter::leaf(text = "SlotClass.SensorProcessingUnit", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityRelativeY( #[rust_sitter::leaf(text = "LogicType.VelocityRelativeY", transform = |s| s.to_string() )] String ),
+     SlotClassCircuitboard( #[rust_sitter::leaf(text = "SlotClass.Circuitboard", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel4( #[rust_sitter::leaf(text = "LogicType.Channel4", transform = |s| s.to_string() )] String ),
+     LogicTypeForceWrite( #[rust_sitter::leaf(text = "LogicType.ForceWrite", transform = |s| s.to_string() )] String ),
+     SortingClassTools( #[rust_sitter::leaf(text = "SortingClass.Tools", transform = |s| s.to_string() )] String ),
+     LogicTypeWeight( #[rust_sitter::leaf(text = "LogicType.Weight", transform = |s| s.to_string() )] String ),
+     LogicTypeReEntryAltitude( #[rust_sitter::leaf(text = "LogicType.ReEntryAltitude", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureOutput( #[rust_sitter::leaf(text = "LogicType.TemperatureOutput", transform = |s| s.to_string() )] String ),
+     SortingClassIces( #[rust_sitter::leaf(text = "SortingClass.Ices", transform = |s| s.to_string() )] String ),
+     SlotClassEgg( #[rust_sitter::leaf(text = "SlotClass.Egg", transform = |s| s.to_string() )] String ),
+     LogicTypeFlush( #[rust_sitter::leaf(text = "LogicType.Flush", transform = |s| s.to_string() )] String ),
+     LogicTypeBurnTimeRemaining( #[rust_sitter::leaf(text = "LogicType.BurnTimeRemaining", transform = |s| s.to_string() )] String ),
+     GasTypeLiquidVolatiles( #[rust_sitter::leaf(text = "GasType.LiquidVolatiles", transform = |s| s.to_string() )] String ),
+     SlotClassCreditCard( #[rust_sitter::leaf(text = "SlotClass.CreditCard", transform = |s| s.to_string() )] String ),
+     ColorWhite( #[rust_sitter::leaf(text = "Color.White", transform = |s| s.to_string() )] String ),
+     LogicTypeTimeToDestination( #[rust_sitter::leaf(text = "LogicType.TimeToDestination", transform = |s| s.to_string() )] String ),
+     LogicTypePressureEfficiency( #[rust_sitter::leaf(text = "LogicType.PressureEfficiency", transform = |s| s.to_string() )] String ),
+     SortingClassStorage( #[rust_sitter::leaf(text = "SortingClass.Storage", transform = |s| s.to_string() )] String ),
+     LogicTypeForwardZ( #[rust_sitter::leaf(text = "LogicType.ForwardZ", transform = |s| s.to_string() )] String ),
+     LogicTypeThrustToWeight( #[rust_sitter::leaf(text = "LogicType.ThrustToWeight", transform = |s| s.to_string() )] String ),
+     LogicTypeDryMass( #[rust_sitter::leaf(text = "LogicType.DryMass", transform = |s| s.to_string() )] String ),
+     LogicTypeReagents( #[rust_sitter::leaf(text = "LogicType.Reagents", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrousOxideInput2( #[rust_sitter::leaf(text = "LogicType.RatioNitrousOxideInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioPollutantOutput2( #[rust_sitter::leaf(text = "LogicType.RatioPollutantOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioSteam( #[rust_sitter::leaf(text = "LogicType.RatioSteam", transform = |s| s.to_string() )] String ),
+     LogicTypeSizeX( #[rust_sitter::leaf(text = "LogicType.SizeX", transform = |s| s.to_string() )] String ),
+     GasTypeOxygen( #[rust_sitter::leaf(text = "GasType.Oxygen", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidOxygenInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidOxygenInput2", transform = |s| s.to_string() )] String ),
+     ColorGray( #[rust_sitter::leaf(text = "Color.Gray", transform = |s| s.to_string() )] String ),
+     LogicTypePressureInput2( #[rust_sitter::leaf(text = "LogicType.PressureInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioVolatilesOutput( #[rust_sitter::leaf(text = "LogicType.RatioVolatilesOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeTotalMoles( #[rust_sitter::leaf(text = "LogicType.TotalMoles", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidOxygenOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidOxygenOutput", transform = |s| s.to_string() )] String ),
+     EntityStateDead( #[rust_sitter::leaf(text = "EntityState.Dead", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityRelativeX( #[rust_sitter::leaf(text = "LogicType.VelocityRelativeX", transform = |s| s.to_string() )] String ),
+     LogicTypePrefabHash( #[rust_sitter::leaf(text = "LogicType.PrefabHash", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioOxygenOutput( #[rust_sitter::leaf(text = "LogicType.RatioOxygenOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidVolatilesOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidVolatilesOutput", transform = |s| s.to_string() )] String ),
+     SlotClassBottle( #[rust_sitter::leaf(text = "SlotClass.Bottle", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioCarbonDioxideOutput( #[rust_sitter::leaf(text = "LogicType.RatioCarbonDioxideOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioWaterOutput2( #[rust_sitter::leaf(text = "LogicType.RatioWaterOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrogenInput( #[rust_sitter::leaf(text = "LogicType.RatioNitrogenInput", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustionLimiter( #[rust_sitter::leaf(text = "LogicType.CombustionLimiter", transform = |s| s.to_string() )] String ),
+     SlotClassBelt( #[rust_sitter::leaf(text = "SlotClass.Belt", transform = |s| s.to_string() )] String ),
+     LogicTypeVolume( #[rust_sitter::leaf(text = "LogicType.Volume", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrousOxide( #[rust_sitter::leaf(text = "LogicType.RatioNitrousOxide", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel3( #[rust_sitter::leaf(text = "LogicType.Channel3", transform = |s| s.to_string() )] String ),
+     SlotClassBlocked( #[rust_sitter::leaf(text = "SlotClass.Blocked", transform = |s| s.to_string() )] String ),
+     DaylightSensorModeVertical( #[rust_sitter::leaf(text = "DaylightSensorMode.Vertical", transform = |s| s.to_string() )] String ),
+     LogicTypeSizeZ( #[rust_sitter::leaf(text = "LogicType.SizeZ", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioSteamOutput( #[rust_sitter::leaf(text = "LogicType.RatioSteamOutput", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeChargeRatio( #[rust_sitter::leaf(text = "LogicSlotType.ChargeRatio", transform = |s| s.to_string() )] String ),
+     LogicTypeNextWeatherEventTime( #[rust_sitter::leaf(text = "LogicType.NextWeatherEventTime", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeCharge( #[rust_sitter::leaf(text = "LogicSlotType.Charge", transform = |s| s.to_string() )] String ),
+     LogicTypePressureSetting( #[rust_sitter::leaf(text = "LogicType.PressureSetting", transform = |s| s.to_string() )] String ),
+     SlotClassLiquidCanister( #[rust_sitter::leaf(text = "SlotClass.LiquidCanister", transform = |s| s.to_string() )] String ),
+     GasTypeLiquidPollutant( #[rust_sitter::leaf(text = "GasType.LiquidPollutant", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeVolume( #[rust_sitter::leaf(text = "LogicSlotType.Volume", transform = |s| s.to_string() )] String ),
+     LogicTypeCollectableGoods( #[rust_sitter::leaf(text = "LogicType.CollectableGoods", transform = |s| s.to_string() )] String ),
+     SlotClassSuit( #[rust_sitter::leaf(text = "SlotClass.Suit", transform = |s| s.to_string() )] String ),
+     GasTypeCarbonDioxide( #[rust_sitter::leaf(text = "GasType.CarbonDioxide", transform = |s| s.to_string() )] String ),
+     ColorBlack( #[rust_sitter::leaf(text = "Color.Black", transform = |s| s.to_string() )] String ),
+     Greater( #[rust_sitter::leaf(text = "Greater", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioCarbonDioxideInput( #[rust_sitter::leaf(text = "LogicType.RatioCarbonDioxideInput", transform = |s| s.to_string() )] String ),
+     LogicTypeContactTypeId( #[rust_sitter::leaf(text = "LogicType.ContactTypeId", transform = |s| s.to_string() )] String ),
+     RobotModeNone( #[rust_sitter::leaf(text = "RobotMode.None", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioCarbonDioxideOutput2( #[rust_sitter::leaf(text = "LogicType.RatioCarbonDioxideOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeFlightControlRule( #[rust_sitter::leaf(text = "LogicType.FlightControlRule", transform = |s| s.to_string() )] String ),
+     LogicTypeForwardX( #[rust_sitter::leaf(text = "LogicType.ForwardX", transform = |s| s.to_string() )] String ),
+     RobotModeRoam( #[rust_sitter::leaf(text = "RobotMode.Roam", transform = |s| s.to_string() )] String ),
+     SortingClassFood( #[rust_sitter::leaf(text = "SortingClass.Food", transform = |s| s.to_string() )] String ),
+     LogicTypeVolumeOfLiquid( #[rust_sitter::leaf(text = "LogicType.VolumeOfLiquid", transform = |s| s.to_string() )] String ),
+     LogicTypeHarvest( #[rust_sitter::leaf(text = "LogicType.Harvest", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustionOutput2( #[rust_sitter::leaf(text = "LogicType.CombustionOutput2", transform = |s| s.to_string() )] String ),
+     ColorPurple( #[rust_sitter::leaf(text = "Color.Purple", transform = |s| s.to_string() )] String ),
+     LogicTypeAcceleration( #[rust_sitter::leaf(text = "LogicType.Acceleration", transform = |s| s.to_string() )] String ),
+     LogicTypeElevatorSpeed( #[rust_sitter::leaf(text = "LogicType.ElevatorSpeed", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioPollutant( #[rust_sitter::leaf(text = "LogicType.RatioPollutant", transform = |s| s.to_string() )] String ),
+     LogicTypeHorizontal( #[rust_sitter::leaf(text = "LogicType.Horizontal", transform = |s| s.to_string() )] String ),
+     VentInward( #[rust_sitter::leaf(text = "Vent.Inward", transform = |s| s.to_string() )] String ),
+     LogicTypePressureInput( #[rust_sitter::leaf(text = "LogicType.PressureInput", transform = |s| s.to_string() )] String ),
+     PowerModeCharged( #[rust_sitter::leaf(text = "PowerMode.Charged", transform = |s| s.to_string() )] String ),
+     SortingClassResources( #[rust_sitter::leaf(text = "SortingClass.Resources", transform = |s| s.to_string() )] String ),
+     LogicTypeCompletionRatio( #[rust_sitter::leaf(text = "LogicType.CompletionRatio", transform = |s| s.to_string() )] String ),
+     SortingClassOres( #[rust_sitter::leaf(text = "SortingClass.Ores", transform = |s| s.to_string() )] String ),
+     GasTypeLiquidNitrousOxide( #[rust_sitter::leaf(text = "GasType.LiquidNitrousOxide", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrousOxideInput( #[rust_sitter::leaf(text = "LogicType.RatioNitrousOxideInput", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel2( #[rust_sitter::leaf(text = "LogicType.Channel2", transform = |s| s.to_string() )] String ),
+     LogicTypeMaximum( #[rust_sitter::leaf(text = "LogicType.Maximum", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustionOutput( #[rust_sitter::leaf(text = "LogicType.CombustionOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioPollutantInput( #[rust_sitter::leaf(text = "LogicType.RatioPollutantInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrogenOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrogenOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeMineablesInVicinity( #[rust_sitter::leaf(text = "LogicType.MineablesInVicinity", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioWaterOutput( #[rust_sitter::leaf(text = "LogicType.RatioWaterOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidCarbonDioxideOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidCarbonDioxideOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeOpen( #[rust_sitter::leaf(text = "LogicType.Open", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioVolatiles( #[rust_sitter::leaf(text = "LogicType.RatioVolatiles", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityY( #[rust_sitter::leaf(text = "LogicType.VelocityY", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidCarbonDioxideInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidCarbonDioxideInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeIndex( #[rust_sitter::leaf(text = "LogicType.Index", transform = |s| s.to_string() )] String ),
+     AirControlPressure( #[rust_sitter::leaf(text = "AirControl.Pressure", transform = |s| s.to_string() )] String ),
+     RobotModeMoveToTarget( #[rust_sitter::leaf(text = "RobotMode.MoveToTarget", transform = |s| s.to_string() )] String ),
+     SlotClassOre( #[rust_sitter::leaf(text = "SlotClass.Ore", transform = |s| s.to_string() )] String ),
+     SlotClassHelmet( #[rust_sitter::leaf(text = "SlotClass.Helmet", transform = |s| s.to_string() )] String ),
+     LogicTypePowerActual( #[rust_sitter::leaf(text = "LogicType.PowerActual", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidOxygenInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidOxygenInput", transform = |s| s.to_string() )] String ),
+     LogicTypeAutoLand( #[rust_sitter::leaf(text = "LogicType.AutoLand", transform = |s| s.to_string() )] String ),
+     LogicTypeSignalStrength( #[rust_sitter::leaf(text = "LogicType.SignalStrength", transform = |s| s.to_string() )] String ),
+     GasTypeNitrousOxide( #[rust_sitter::leaf(text = "GasType.NitrousOxide", transform = |s| s.to_string() )] String ),
+     LogicTypeMass( #[rust_sitter::leaf(text = "LogicType.Mass", transform = |s| s.to_string() )] String ),
+     LogicTypeAlignmentError( #[rust_sitter::leaf(text = "LogicType.AlignmentError", transform = |s| s.to_string() )] String ),
+     LogicTypePressureOutput( #[rust_sitter::leaf(text = "LogicType.PressureOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeTargetY( #[rust_sitter::leaf(text = "LogicType.TargetY", transform = |s| s.to_string() )] String ),
+     PowerModeDischarged( #[rust_sitter::leaf(text = "PowerMode.Discharged", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeNone( #[rust_sitter::leaf(text = "LogicSlotType.None", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityMagnitude( #[rust_sitter::leaf(text = "LogicType.VelocityMagnitude", transform = |s| s.to_string() )] String ),
+     LogicTypeTotalMolesOutput2( #[rust_sitter::leaf(text = "LogicType.TotalMolesOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureSetting( #[rust_sitter::leaf(text = "LogicType.TemperatureSetting", transform = |s| s.to_string() )] String ),
+     LogicTypePressure( #[rust_sitter::leaf(text = "LogicType.Pressure", transform = |s| s.to_string() )] String ),
+     LogicTypeWorkingGasEfficiency( #[rust_sitter::leaf(text = "LogicType.WorkingGasEfficiency", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrogenOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrogenOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrogen( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrogen", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureExternal( #[rust_sitter::leaf(text = "LogicType.TemperatureExternal", transform = |s| s.to_string() )] String ),
+     LogicTypeDrillCondition( #[rust_sitter::leaf(text = "LogicType.DrillCondition", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeReferenceId( #[rust_sitter::leaf(text = "LogicSlotType.ReferenceId", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeEfficiency( #[rust_sitter::leaf(text = "LogicSlotType.Efficiency", transform = |s| s.to_string() )] String ),
+     LogicTypePressureInternal( #[rust_sitter::leaf(text = "LogicType.PressureInternal", transform = |s| s.to_string() )] String ),
+     LogicTypeTrueAnomaly( #[rust_sitter::leaf(text = "LogicType.TrueAnomaly", transform = |s| s.to_string() )] String ),
+     LogicSlotTypePrefabHash( #[rust_sitter::leaf(text = "LogicSlotType.PrefabHash", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioOxygenInput( #[rust_sitter::leaf(text = "LogicType.RatioOxygenInput", transform = |s| s.to_string() )] String ),
+     LogicTypePressureExternal( #[rust_sitter::leaf(text = "LogicType.PressureExternal", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrogenOutput2( #[rust_sitter::leaf(text = "LogicType.RatioNitrogenOutput2", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeMaxQuantity( #[rust_sitter::leaf(text = "LogicSlotType.MaxQuantity", transform = |s| s.to_string() )] String ),
+     LogicTypeMineablesInQueue( #[rust_sitter::leaf(text = "LogicType.MineablesInQueue", transform = |s| s.to_string() )] String ),
+     ColorKhaki( #[rust_sitter::leaf(text = "Color.Khaki", transform = |s| s.to_string() )] String ),
+     LogicTypePressureOutput2( #[rust_sitter::leaf(text = "LogicType.PressureOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeExhaustVelocity( #[rust_sitter::leaf(text = "LogicType.ExhaustVelocity", transform = |s| s.to_string() )] String ),
+     SortingClassDefault( #[rust_sitter::leaf(text = "SortingClass.Default", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustion( #[rust_sitter::leaf(text = "LogicType.Combustion", transform = |s| s.to_string() )] String ),
+     LogicTypeImportCount( #[rust_sitter::leaf(text = "LogicType.ImportCount", transform = |s| s.to_string() )] String ),
+     LogicTypeOrientation( #[rust_sitter::leaf(text = "LogicType.Orientation", transform = |s| s.to_string() )] String ),
+     LogicTypeSizeY( #[rust_sitter::leaf(text = "LogicType.SizeY", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel0( #[rust_sitter::leaf(text = "LogicType.Channel0", transform = |s| s.to_string() )] String ),
+     SlotClassScanningHead( #[rust_sitter::leaf(text = "SlotClass.ScanningHead", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrousOxideOutput2( #[rust_sitter::leaf(text = "LogicType.RatioNitrousOxideOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel1( #[rust_sitter::leaf(text = "LogicType.Channel1", transform = |s| s.to_string() )] String ),
+     LogicTypeSetting( #[rust_sitter::leaf(text = "LogicType.Setting", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeTemperature( #[rust_sitter::leaf(text = "LogicSlotType.Temperature", transform = |s| s.to_string() )] String ),
+     LogicTypeExportCount( #[rust_sitter::leaf(text = "LogicType.ExportCount", transform = |s| s.to_string() )] String ),
+     LogicTypeReferenceId( #[rust_sitter::leaf(text = "LogicType.ReferenceId", transform = |s| s.to_string() )] String ),
+     SlotClassDataDisk( #[rust_sitter::leaf(text = "SlotClass.DataDisk", transform = |s| s.to_string() )] String ),
+     TransmitterModeActive( #[rust_sitter::leaf(text = "TransmitterMode.Active", transform = |s| s.to_string() )] String ),
+     PowerModeIdle( #[rust_sitter::leaf(text = "PowerMode.Idle", transform = |s| s.to_string() )] String ),
+     LogicTypeTime( #[rust_sitter::leaf(text = "LogicType.Time", transform = |s| s.to_string() )] String ),
+     LogicTypeEntityState( #[rust_sitter::leaf(text = "LogicType.EntityState", transform = |s| s.to_string() )] String ),
+     SlotClassAppliance( #[rust_sitter::leaf(text = "SlotClass.Appliance", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidVolatilesInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidVolatilesInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioOxygen( #[rust_sitter::leaf(text = "LogicType.RatioOxygen", transform = |s| s.to_string() )] String ),
+     LogicTypeMode( #[rust_sitter::leaf(text = "LogicType.Mode", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureInput( #[rust_sitter::leaf(text = "LogicType.TemperatureInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrousOxideInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrousOxideInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureInput2( #[rust_sitter::leaf(text = "LogicType.TemperatureInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeTotalMolesInput( #[rust_sitter::leaf(text = "LogicType.TotalMolesInput", transform = |s| s.to_string() )] String ),
+     LogicTypeIdle( #[rust_sitter::leaf(text = "LogicType.Idle", transform = |s| s.to_string() )] String ),
+     LogicTypePower( #[rust_sitter::leaf(text = "LogicType.Power", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioVolatilesInput2( #[rust_sitter::leaf(text = "LogicType.RatioVolatilesInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrousOxideOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrousOxideOutput2", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeClass( #[rust_sitter::leaf(text = "LogicSlotType.Class", transform = |s| s.to_string() )] String ),
+     SlotClassLiquidBottle( #[rust_sitter::leaf(text = "SlotClass.LiquidBottle", transform = |s| s.to_string() )] String ),
+     SlotClassPlant( #[rust_sitter::leaf(text = "SlotClass.Plant", transform = |s| s.to_string() )] String ),
+     SlotClassGlasses( #[rust_sitter::leaf(text = "SlotClass.Glasses", transform = |s| s.to_string() )] String ),
+     VentOutward( #[rust_sitter::leaf(text = "Vent.Outward", transform = |s| s.to_string() )] String ),
+     LogicTypeThrottle( #[rust_sitter::leaf(text = "LogicType.Throttle", transform = |s| s.to_string() )] String ),
+     Less( #[rust_sitter::leaf(text = "Less", transform = |s| s.to_string() )] String ),
+     LogicTypeQuantity( #[rust_sitter::leaf(text = "LogicType.Quantity", transform = |s| s.to_string() )] String ),
+     LogicTypeProgress( #[rust_sitter::leaf(text = "LogicType.Progress", transform = |s| s.to_string() )] String ),
+     LogicTypeError( #[rust_sitter::leaf(text = "LogicType.Error", transform = |s| s.to_string() )] String ),
+     SortingClassKits( #[rust_sitter::leaf(text = "SortingClass.Kits", transform = |s| s.to_string() )] String ),
+     SlotClassUniform( #[rust_sitter::leaf(text = "SlotClass.Uniform", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel6( #[rust_sitter::leaf(text = "LogicType.Channel6", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeLock( #[rust_sitter::leaf(text = "LogicSlotType.Lock", transform = |s| s.to_string() )] String ),
+     SlotClassBack( #[rust_sitter::leaf(text = "SlotClass.Back", transform = |s| s.to_string() )] String ),
+     LogicTypeVertical( #[rust_sitter::leaf(text = "LogicType.Vertical", transform = |s| s.to_string() )] String ),
+     GasTypeLiquidCarbonDioxide( #[rust_sitter::leaf(text = "GasType.LiquidCarbonDioxide", transform = |s| s.to_string() )] String ),
+     LogicTypeSolarIrradiance( #[rust_sitter::leaf(text = "LogicType.SolarIrradiance", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrogenInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrogenInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRpm( #[rust_sitter::leaf(text = "LogicType.Rpm", transform = |s| s.to_string() )] String ),
+     LogicTypeFiltration( #[rust_sitter::leaf(text = "LogicType.Filtration", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrousOxide( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrousOxide", transform = |s| s.to_string() )] String ),
+     LogicTypeOrbitPeriod( #[rust_sitter::leaf(text = "LogicType.OrbitPeriod", transform = |s| s.to_string() )] String ),
+     LogicTypePowerRequired( #[rust_sitter::leaf(text = "LogicType.PowerRequired", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrogen( #[rust_sitter::leaf(text = "LogicType.RatioNitrogen", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeOpen( #[rust_sitter::leaf(text = "LogicSlotType.Open", transform = |s| s.to_string() )] String ),
+     LogicTypeCurrentResearchPodType( #[rust_sitter::leaf(text = "LogicType.CurrentResearchPodType", transform = |s| s.to_string() )] String ),
+     EntityStateUnconscious( #[rust_sitter::leaf(text = "EntityState.Unconscious", transform = |s| s.to_string() )] String ),
+     LogicTypeSettingOutput( #[rust_sitter::leaf(text = "LogicType.SettingOutput", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeSeeding( #[rust_sitter::leaf(text = "LogicSlotType.Seeding", transform = |s| s.to_string() )] String ),
+     ElevatorModeStationary( #[rust_sitter::leaf(text = "ElevatorMode.Stationary", transform = |s| s.to_string() )] String ),
+     PowerModeDischarging( #[rust_sitter::leaf(text = "PowerMode.Discharging", transform = |s| s.to_string() )] String ),
+     LogicTypeFuel( #[rust_sitter::leaf(text = "LogicType.Fuel", transform = |s| s.to_string() )] String ),
+     LogicTypeSettingInput( #[rust_sitter::leaf(text = "LogicType.SettingInput", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityZ( #[rust_sitter::leaf(text = "LogicType.VelocityZ", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeHealth( #[rust_sitter::leaf(text = "LogicSlotType.Health", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeSortingClass( #[rust_sitter::leaf(text = "LogicSlotType.SortingClass", transform = |s| s.to_string() )] String ),
+     LogicTypeTargetX( #[rust_sitter::leaf(text = "LogicType.TargetX", transform = |s| s.to_string() )] String ),
+     SlotClassIngot( #[rust_sitter::leaf(text = "SlotClass.Ingot", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeOn( #[rust_sitter::leaf(text = "LogicSlotType.On", transform = |s| s.to_string() )] String ),
+     LogicTypeTargetZ( #[rust_sitter::leaf(text = "LogicType.TargetZ", transform = |s| s.to_string() )] String ),
+     ColorYellow( #[rust_sitter::leaf(text = "Color.Yellow", transform = |s| s.to_string() )] String ),
+     SlotClassTool( #[rust_sitter::leaf(text = "SlotClass.Tool", transform = |s| s.to_string() )] String ),
+     DaylightSensorModeDefault( #[rust_sitter::leaf(text = "DaylightSensorMode.Default", transform = |s| s.to_string() )] String ),
+     LogicSlotTypePressureWaste( #[rust_sitter::leaf(text = "LogicSlotType.PressureWaste", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrousOxideOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrousOxideOutput", transform = |s| s.to_string() )] String ),
+     SlotClassFlare( #[rust_sitter::leaf(text = "SlotClass.Flare", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeMature( #[rust_sitter::leaf(text = "LogicSlotType.Mature", transform = |s| s.to_string() )] String ),
+     LogicTypeThrust( #[rust_sitter::leaf(text = "LogicType.Thrust", transform = |s| s.to_string() )] String ),
+     LogicTypeRatio( #[rust_sitter::leaf(text = "LogicType.Ratio", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidNitrousOxideInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidNitrousOxideInput", transform = |s| s.to_string() )] String ),
+     LogicTypeDistanceAu( #[rust_sitter::leaf(text = "LogicType.DistanceAu", transform = |s| s.to_string() )] String ),
+     ElevatorModeDownward( #[rust_sitter::leaf(text = "ElevatorMode.Downward", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrogenOutput( #[rust_sitter::leaf(text = "LogicType.RatioNitrogenOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeSoundAlert( #[rust_sitter::leaf(text = "LogicType.SoundAlert", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidVolatilesOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidVolatilesOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidVolatilesInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidVolatilesInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidPollutantOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidPollutantOutput2", transform = |s| s.to_string() )] String ),
+     SlotClassDirtCanister( #[rust_sitter::leaf(text = "SlotClass.DirtCanister", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidVolatiles( #[rust_sitter::leaf(text = "LogicType.RatioLiquidVolatiles", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidOxygenOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidOxygenOutput2", transform = |s| s.to_string() )] String ),
+     SortingClassAppliances( #[rust_sitter::leaf(text = "SortingClass.Appliances", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioOxygenInput2( #[rust_sitter::leaf(text = "LogicType.RatioOxygenInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidCarbonDioxideOutput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidCarbonDioxideOutput2", transform = |s| s.to_string() )] String ),
+     LogicTypeApex( #[rust_sitter::leaf(text = "LogicType.Apex", transform = |s| s.to_string() )] String ),
+     LogicTypePositionX( #[rust_sitter::leaf(text = "LogicType.PositionX", transform = |s| s.to_string() )] String ),
+     LogicTypeBpm( #[rust_sitter::leaf(text = "LogicType.Bpm", transform = |s| s.to_string() )] String ),
+     LogicTypeRequestHash( #[rust_sitter::leaf(text = "LogicType.RequestHash", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeOccupied( #[rust_sitter::leaf(text = "LogicSlotType.Occupied", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeGrowth( #[rust_sitter::leaf(text = "LogicSlotType.Growth", transform = |s| s.to_string() )] String ),
+     GasTypeLiquidNitrogen( #[rust_sitter::leaf(text = "GasType.LiquidNitrogen", transform = |s| s.to_string() )] String ),
+     LogicTypeLock( #[rust_sitter::leaf(text = "LogicType.Lock", transform = |s| s.to_string() )] String ),
+     ColorRed( #[rust_sitter::leaf(text = "Color.Red", transform = |s| s.to_string() )] String ),
+     SortingClassClothing( #[rust_sitter::leaf(text = "SortingClass.Clothing", transform = |s| s.to_string() )] String ),
+     LogicTypeCombustionInput( #[rust_sitter::leaf(text = "LogicType.CombustionInput", transform = |s| s.to_string() )] String ),
+     LogicTypeOutput( #[rust_sitter::leaf(text = "LogicType.Output", transform = |s| s.to_string() )] String ),
+     LogicTypeInterrogationProgress( #[rust_sitter::leaf(text = "LogicType.InterrogationProgress", transform = |s| s.to_string() )] String ),
+     LogicTypeCelestialHash( #[rust_sitter::leaf(text = "LogicType.CelestialHash", transform = |s| s.to_string() )] String ),
+     LogicTypeAutoShutOff( #[rust_sitter::leaf(text = "LogicType.AutoShutOff", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioWater( #[rust_sitter::leaf(text = "LogicType.RatioWater", transform = |s| s.to_string() )] String ),
+     LogicTypeTotalMolesOutput( #[rust_sitter::leaf(text = "LogicType.TotalMolesOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrousOxideOutput( #[rust_sitter::leaf(text = "LogicType.RatioNitrousOxideOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperature( #[rust_sitter::leaf(text = "LogicType.Temperature", transform = |s| s.to_string() )] String ),
+     LogicTypeActivate( #[rust_sitter::leaf(text = "LogicType.Activate", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioCarbonDioxideInput2( #[rust_sitter::leaf(text = "LogicType.RatioCarbonDioxideInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeSolarAngle( #[rust_sitter::leaf(text = "LogicType.SolarAngle", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel5( #[rust_sitter::leaf(text = "LogicType.Channel5", transform = |s| s.to_string() )] String ),
+     LogicTypeDistanceKm( #[rust_sitter::leaf(text = "LogicType.DistanceKm", transform = |s| s.to_string() )] String ),
+     LogicTypeSignalId( #[rust_sitter::leaf(text = "LogicType.SignalID", transform = |s| s.to_string() )] String ),
+     SlotClassTorpedo( #[rust_sitter::leaf(text = "SlotClass.Torpedo", transform = |s| s.to_string() )] String ),
+     AirControlOffline( #[rust_sitter::leaf(text = "AirControl.Offline", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeQuantity( #[rust_sitter::leaf(text = "LogicSlotType.Quantity", transform = |s| s.to_string() )] String ),
+     SlotClassSoundCartridge( #[rust_sitter::leaf(text = "SlotClass.SoundCartridge", transform = |s| s.to_string() )] String ),
+     GasTypeWater( #[rust_sitter::leaf(text = "GasType.Water", transform = |s| s.to_string() )] String ),
+     LogicTypeDestinationCode( #[rust_sitter::leaf(text = "LogicType.DestinationCode", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioNitrogenInput2( #[rust_sitter::leaf(text = "LogicType.RatioNitrogenInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidCarbonDioxide( #[rust_sitter::leaf(text = "LogicType.RatioLiquidCarbonDioxide", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidCarbonDioxideInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidCarbonDioxideInput", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidPollutantInput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidPollutantInput", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityX( #[rust_sitter::leaf(text = "LogicType.VelocityX", transform = |s| s.to_string() )] String ),
+     RobotModeStorageFull( #[rust_sitter::leaf(text = "RobotMode.StorageFull", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioPollutantInput2( #[rust_sitter::leaf(text = "LogicType.RatioPollutantInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeManualResearchRequiredPod( #[rust_sitter::leaf(text = "LogicType.ManualResearchRequiredPod", transform = |s| s.to_string() )] String ),
+     LogicTypeTotalMolesInput2( #[rust_sitter::leaf(text = "LogicType.TotalMolesInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioWaterInput( #[rust_sitter::leaf(text = "LogicType.RatioWaterInput", transform = |s| s.to_string() )] String ),
+     LogicTypeTargetPadIndex( #[rust_sitter::leaf(text = "LogicType.TargetPadIndex", transform = |s| s.to_string() )] String ),
+     LogicSlotTypeDamage( #[rust_sitter::leaf(text = "LogicSlotType.Damage", transform = |s| s.to_string() )] String ),
+     SlotClassNone( #[rust_sitter::leaf(text = "SlotClass.None", transform = |s| s.to_string() )] String ),
+     SlotClassAccessCard( #[rust_sitter::leaf(text = "SlotClass.AccessCard", transform = |s| s.to_string() )] String ),
+     LogicTypeElevatorLevel( #[rust_sitter::leaf(text = "LogicType.ElevatorLevel", transform = |s| s.to_string() )] String ),
+     SlotClassBattery( #[rust_sitter::leaf(text = "SlotClass.Battery", transform = |s| s.to_string() )] String ),
+     ElevatorModeUpward( #[rust_sitter::leaf(text = "ElevatorMode.Upward", transform = |s| s.to_string() )] String ),
+     ColorOrange( #[rust_sitter::leaf(text = "Color.Orange", transform = |s| s.to_string() )] String ),
+     LogicTypeVelocityRelativeZ( #[rust_sitter::leaf(text = "LogicType.VelocityRelativeZ", transform = |s| s.to_string() )] String ),
+     NotEquals( #[rust_sitter::leaf(text = "NotEquals", transform = |s| s.to_string() )] String ),
+     SlotClassCircuit( #[rust_sitter::leaf(text = "SlotClass.Circuit", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidPollutantOutput( #[rust_sitter::leaf(text = "LogicType.RatioLiquidPollutantOutput", transform = |s| s.to_string() )] String ),
+     LogicTypeWattsReachingContact( #[rust_sitter::leaf(text = "LogicType.WattsReachingContact", transform = |s| s.to_string() )] String ),
+     LogicTypePositionZ( #[rust_sitter::leaf(text = "LogicType.PositionZ", transform = |s| s.to_string() )] String ),
+     LogicTypeForwardY( #[rust_sitter::leaf(text = "LogicType.ForwardY", transform = |s| s.to_string() )] String ),
+     GasTypeSteam( #[rust_sitter::leaf(text = "GasType.Steam", transform = |s| s.to_string() )] String ),
+     SlotClassMagazine( #[rust_sitter::leaf(text = "SlotClass.Magazine", transform = |s| s.to_string() )] String ),
+     LogicTypeTemperatureDifferentialEfficiency( #[rust_sitter::leaf(text = "LogicType.TemperatureDifferentialEfficiency", transform = |s| s.to_string() )] String ),
+     LogicSlotTypePressureAir( #[rust_sitter::leaf(text = "LogicSlotType.PressureAir", transform = |s| s.to_string() )] String ),
+     DaylightSensorModeHorizontal( #[rust_sitter::leaf(text = "DaylightSensorMode.Horizontal", transform = |s| s.to_string() )] String ),
+     RobotModeUnload( #[rust_sitter::leaf(text = "RobotMode.Unload", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidPollutantInput2( #[rust_sitter::leaf(text = "LogicType.RatioLiquidPollutantInput2", transform = |s| s.to_string() )] String ),
+     LogicTypeAirRelease( #[rust_sitter::leaf(text = "LogicType.AirRelease", transform = |s| s.to_string() )] String ),
+     LogicTypeChannel7( #[rust_sitter::leaf(text = "LogicType.Channel7", transform = |s| s.to_string() )] String ),
+     ColorBlue( #[rust_sitter::leaf(text = "Color.Blue", transform = |s| s.to_string() )] String ),
+     EntityStateDecay( #[rust_sitter::leaf(text = "EntityState.Decay", transform = |s| s.to_string() )] String ),
+     RobotModePathToTarget( #[rust_sitter::leaf(text = "RobotMode.PathToTarget", transform = |s| s.to_string() )] String ),
+     LogicTypeRequiredPower( #[rust_sitter::leaf(text = "LogicType.RequiredPower", transform = |s| s.to_string() )] String ),
+     LogicTypeReturnFuelCost( #[rust_sitter::leaf(text = "LogicType.ReturnFuelCost", transform = |s| s.to_string() )] String ),
+     TransmitterModePassive( #[rust_sitter::leaf(text = "TransmitterMode.Passive", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioLiquidPollutant( #[rust_sitter::leaf(text = "LogicType.RatioLiquidPollutant", transform = |s| s.to_string() )] String ),
+     LogicTypeRecipeHash( #[rust_sitter::leaf(text = "LogicType.RecipeHash", transform = |s| s.to_string() )] String ),
+     SlotClassCartridge( #[rust_sitter::leaf(text = "SlotClass.Cartridge", transform = |s| s.to_string() )] String ),
+     SlotClassWreckage( #[rust_sitter::leaf(text = "SlotClass.Wreckage", transform = |s| s.to_string() )] String ),
+     LogicTypePowerGeneration( #[rust_sitter::leaf(text = "LogicType.PowerGeneration", transform = |s| s.to_string() )] String ),
+     LogicTypeClearMemory( #[rust_sitter::leaf(text = "LogicType.ClearMemory", transform = |s| s.to_string() )] String ),
+     LogicTypeRatioSteamInput2( #[rust_sitter::leaf(text = "LogicType.RatioSteamInput2", transform = |s| s.to_string() )] String ),
+}
--- a/ic10emu/src/grammar/ic10/instructions.rs
+++ b/ic10emu/src/grammar/ic10/instructions.rs
@@ -0,0 +1,145 @@
+// GENERATED CODE DO NOT MODIFY
+#[derive(PartialEq, Debug)]
+pub enum InstructionOp {
+     Acos( #[rust_sitter::leaf(text = "acos", transform = |s| s.to_string() )] String ),
+     Breq( #[rust_sitter::leaf(text = "breq", transform = |s| s.to_string() )] String ),
+     Hcf( #[rust_sitter::leaf(text = "hcf", transform = |s| s.to_string() )] String ),
+     Jr( #[rust_sitter::leaf(text = "jr", transform = |s| s.to_string() )] String ),
+     Brgtz( #[rust_sitter::leaf(text = "brgtz", transform = |s| s.to_string() )] String ),
+     Mul( #[rust_sitter::leaf(text = "mul", transform = |s| s.to_string() )] String ),
+     Atan2( #[rust_sitter::leaf(text = "atan2", transform = |s| s.to_string() )] String ),
+     Blezal( #[rust_sitter::leaf(text = "blezal", transform = |s| s.to_string() )] String ),
+     Slt( #[rust_sitter::leaf(text = "slt", transform = |s| s.to_string() )] String ),
+     Bnezal( #[rust_sitter::leaf(text = "bnezal", transform = |s| s.to_string() )] String ),
+     Sdse( #[rust_sitter::leaf(text = "sdse", transform = |s| s.to_string() )] String ),
+     Sgez( #[rust_sitter::leaf(text = "sgez", transform = |s| s.to_string() )] String ),
+     Snan( #[rust_sitter::leaf(text = "snan", transform = |s| s.to_string() )] String ),
+     Lb( #[rust_sitter::leaf(text = "lb", transform = |s| s.to_string() )] String ),
+     Bnez( #[rust_sitter::leaf(text = "bnez", transform = |s| s.to_string() )] String ),
+     Pop( #[rust_sitter::leaf(text = "pop", transform = |s| s.to_string() )] String ),
+     Put( #[rust_sitter::leaf(text = "put", transform = |s| s.to_string() )] String ),
+     Snaz( #[rust_sitter::leaf(text = "snaz", transform = |s| s.to_string() )] String ),
+     Xor( #[rust_sitter::leaf(text = "xor", transform = |s| s.to_string() )] String ),
+     Sbs( #[rust_sitter::leaf(text = "sbs", transform = |s| s.to_string() )] String ),
+     Or( #[rust_sitter::leaf(text = "or", transform = |s| s.to_string() )] String ),
+     Log( #[rust_sitter::leaf(text = "log", transform = |s| s.to_string() )] String ),
+     Bleal( #[rust_sitter::leaf(text = "bleal", transform = |s| s.to_string() )] String ),
+     Brne( #[rust_sitter::leaf(text = "brne", transform = |s| s.to_string() )] String ),
+     Bgtzal( #[rust_sitter::leaf(text = "bgtzal", transform = |s| s.to_string() )] String ),
+     Lbn( #[rust_sitter::leaf(text = "lbn", transform = |s| s.to_string() )] String ),
+     Lr( #[rust_sitter::leaf(text = "lr", transform = |s| s.to_string() )] String ),
+     Snanz( #[rust_sitter::leaf(text = "snanz", transform = |s| s.to_string() )] String ),
+     Bdnsal( #[rust_sitter::leaf(text = "bdnsal", transform = |s| s.to_string() )] String ),
+     Brdns( #[rust_sitter::leaf(text = "brdns", transform = |s| s.to_string() )] String ),
+     Bltz( #[rust_sitter::leaf(text = "bltz", transform = |s| s.to_string() )] String ),
+     Tan( #[rust_sitter::leaf(text = "tan", transform = |s| s.to_string() )] String ),
+     Sla( #[rust_sitter::leaf(text = "sla", transform = |s| s.to_string() )] String ),
+     Bnan( #[rust_sitter::leaf(text = "bnan", transform = |s| s.to_string() )] String ),
+     Seqz( #[rust_sitter::leaf(text = "seqz", transform = |s| s.to_string() )] String ),
+     Bdse( #[rust_sitter::leaf(text = "bdse", transform = |s| s.to_string() )] String ),
+     Push( #[rust_sitter::leaf(text = "push", transform = |s| s.to_string() )] String ),
+     Sra( #[rust_sitter::leaf(text = "sra", transform = |s| s.to_string() )] String ),
+     Bnaz( #[rust_sitter::leaf(text = "bnaz", transform = |s| s.to_string() )] String ),
+     Select( #[rust_sitter::leaf(text = "select", transform = |s| s.to_string() )] String ),
+     Poke( #[rust_sitter::leaf(text = "poke", transform = |s| s.to_string() )] String ),
+     Sub( #[rust_sitter::leaf(text = "sub", transform = |s| s.to_string() )] String ),
+     Bna( #[rust_sitter::leaf(text = "bna", transform = |s| s.to_string() )] String ),
+     Bgtal( #[rust_sitter::leaf(text = "bgtal", transform = |s| s.to_string() )] String ),
+     Yield( #[rust_sitter::leaf(text = "yield", transform = |s| s.to_string() )] String ),
+     Bgeal( #[rust_sitter::leaf(text = "bgeal", transform = |s| s.to_string() )] String ),
+     Lbs( #[rust_sitter::leaf(text = "lbs", transform = |s| s.to_string() )] String ),
+     Atan( #[rust_sitter::leaf(text = "atan", transform = |s| s.to_string() )] String ),
+     Brltz( #[rust_sitter::leaf(text = "brltz", transform = |s| s.to_string() )] String ),
+     Bdseal( #[rust_sitter::leaf(text = "bdseal", transform = |s| s.to_string() )] String ),
+     Blez( #[rust_sitter::leaf(text = "blez", transform = |s| s.to_string() )] String ),
+     Brapz( #[rust_sitter::leaf(text = "brapz", transform = |s| s.to_string() )] String ),
+     Bap( #[rust_sitter::leaf(text = "bap", transform = |s| s.to_string() )] String ),
+     Div( #[rust_sitter::leaf(text = "div", transform = |s| s.to_string() )] String ),
+     Ls( #[rust_sitter::leaf(text = "ls", transform = |s| s.to_string() )] String ),
+     Brnaz( #[rust_sitter::leaf(text = "brnaz", transform = |s| s.to_string() )] String ),
+     Ss( #[rust_sitter::leaf(text = "ss", transform = |s| s.to_string() )] String ),
+     J( #[rust_sitter::leaf(text = "j", transform = |s| s.to_string() )] String ),
+     Snez( #[rust_sitter::leaf(text = "snez", transform = |s| s.to_string() )] String ),
+     Brnez( #[rust_sitter::leaf(text = "brnez", transform = |s| s.to_string() )] String ),
+     Sltz( #[rust_sitter::leaf(text = "sltz", transform = |s| s.to_string() )] String ),
+     Move( #[rust_sitter::leaf(text = "move", transform = |s| s.to_string() )] String ),
+     Cos( #[rust_sitter::leaf(text = "cos", transform = |s| s.to_string() )] String ),
+     Seq( #[rust_sitter::leaf(text = "seq", transform = |s| s.to_string() )] String ),
+     Sqrt( #[rust_sitter::leaf(text = "sqrt", transform = |s| s.to_string() )] String ),
+     Srl( #[rust_sitter::leaf(text = "srl", transform = |s| s.to_string() )] String ),
+     Brgez( #[rust_sitter::leaf(text = "brgez", transform = |s| s.to_string() )] String ),
+     Bgez( #[rust_sitter::leaf(text = "bgez", transform = |s| s.to_string() )] String ),
+     Brlt( #[rust_sitter::leaf(text = "brlt", transform = |s| s.to_string() )] String ),
+     Define( #[rust_sitter::leaf(text = "define", transform = |s| s.to_string() )] String ),
+     Brle( #[rust_sitter::leaf(text = "brle", transform = |s| s.to_string() )] String ),
+     Add( #[rust_sitter::leaf(text = "add", transform = |s| s.to_string() )] String ),
+     Abs( #[rust_sitter::leaf(text = "abs", transform = |s| s.to_string() )] String ),
+     Brna( #[rust_sitter::leaf(text = "brna", transform = |s| s.to_string() )] String ),
+     Mod( #[rust_sitter::leaf(text = "mod", transform = |s| s.to_string() )] String ),
+     Rand( #[rust_sitter::leaf(text = "rand", transform = |s| s.to_string() )] String ),
+     Beq( #[rust_sitter::leaf(text = "beq", transform = |s| s.to_string() )] String ),
+     Sd( #[rust_sitter::leaf(text = "sd", transform = |s| s.to_string() )] String ),
+     Trunc( #[rust_sitter::leaf(text = "trunc", transform = |s| s.to_string() )] String ),
+     Sna( #[rust_sitter::leaf(text = "sna", transform = |s| s.to_string() )] String ),
+     Bnaal( #[rust_sitter::leaf(text = "bnaal", transform = |s| s.to_string() )] String ),
+     Bgtz( #[rust_sitter::leaf(text = "bgtz", transform = |s| s.to_string() )] String ),
+     Getd( #[rust_sitter::leaf(text = "getd", transform = |s| s.to_string() )] String ),
+     Bne( #[rust_sitter::leaf(text = "bne", transform = |s| s.to_string() )] String ),
+     Sgtz( #[rust_sitter::leaf(text = "sgtz", transform = |s| s.to_string() )] String ),
+     Sll( #[rust_sitter::leaf(text = "sll", transform = |s| s.to_string() )] String ),
+     Sleep( #[rust_sitter::leaf(text = "sleep", transform = |s| s.to_string() )] String ),
+     Bge( #[rust_sitter::leaf(text = "bge", transform = |s| s.to_string() )] String ),
+     Beqal( #[rust_sitter::leaf(text = "beqal", transform = |s| s.to_string() )] String ),
+     Bltzal( #[rust_sitter::leaf(text = "bltzal", transform = |s| s.to_string() )] String ),
+     Ceil( #[rust_sitter::leaf(text = "ceil", transform = |s| s.to_string() )] String ),
+     Sap( #[rust_sitter::leaf(text = "sap", transform = |s| s.to_string() )] String ),
+     Sin( #[rust_sitter::leaf(text = "sin", transform = |s| s.to_string() )] String ),
+     Label( #[rust_sitter::leaf(text = "label", transform = |s| s.to_string() )] String ),
+     Not( #[rust_sitter::leaf(text = "not", transform = |s| s.to_string() )] String ),
+     Sne( #[rust_sitter::leaf(text = "sne", transform = |s| s.to_string() )] String ),
+     Bneal( #[rust_sitter::leaf(text = "bneal", transform = |s| s.to_string() )] String ),
+     Brlez( #[rust_sitter::leaf(text = "brlez", transform = |s| s.to_string() )] String ),
+     Lbns( #[rust_sitter::leaf(text = "lbns", transform = |s| s.to_string() )] String ),
+     Bapzal( #[rust_sitter::leaf(text = "bapzal", transform = |s| s.to_string() )] String ),
+     Bgt( #[rust_sitter::leaf(text = "bgt", transform = |s| s.to_string() )] String ),
+     Brdse( #[rust_sitter::leaf(text = "brdse", transform = |s| s.to_string() )] String ),
+     Min( #[rust_sitter::leaf(text = "min", transform = |s| s.to_string() )] String ),
+     Round( #[rust_sitter::leaf(text = "round", transform = |s| s.to_string() )] String ),
+     Brgt( #[rust_sitter::leaf(text = "brgt", transform = |s| s.to_string() )] String ),
+     Alias( #[rust_sitter::leaf(text = "alias", transform = |s| s.to_string() )] String ),
+     Brap( #[rust_sitter::leaf(text = "brap", transform = |s| s.to_string() )] String ),
+     Max( #[rust_sitter::leaf(text = "max", transform = |s| s.to_string() )] String ),
+     Floor( #[rust_sitter::leaf(text = "floor", transform = |s| s.to_string() )] String ),
+     Nor( #[rust_sitter::leaf(text = "nor", transform = |s| s.to_string() )] String ),
+     Sgt( #[rust_sitter::leaf(text = "sgt", transform = |s| s.to_string() )] String ),
+     Exp( #[rust_sitter::leaf(text = "exp", transform = |s| s.to_string() )] String ),
+     Sge( #[rust_sitter::leaf(text = "sge", transform = |s| s.to_string() )] String ),
+     Sle( #[rust_sitter::leaf(text = "sle", transform = |s| s.to_string() )] String ),
+     Blt( #[rust_sitter::leaf(text = "blt", transform = |s| s.to_string() )] String ),
+     Beqzal( #[rust_sitter::leaf(text = "beqzal", transform = |s| s.to_string() )] String ),
+     Peek( #[rust_sitter::leaf(text = "peek", transform = |s| s.to_string() )] String ),
+     Slez( #[rust_sitter::leaf(text = "slez", transform = |s| s.to_string() )] String ),
+     Brnan( #[rust_sitter::leaf(text = "brnan", transform = |s| s.to_string() )] String ),
+     And( #[rust_sitter::leaf(text = "and", transform = |s| s.to_string() )] String ),
+     Putd( #[rust_sitter::leaf(text = "putd", transform = |s| s.to_string() )] String ),
+     Ld( #[rust_sitter::leaf(text = "ld", transform = |s| s.to_string() )] String ),
+     Asin( #[rust_sitter::leaf(text = "asin", transform = |s| s.to_string() )] String ),
+     Bapz( #[rust_sitter::leaf(text = "bapz", transform = |s| s.to_string() )] String ),
+     Ble( #[rust_sitter::leaf(text = "ble", transform = |s| s.to_string() )] String ),
+     Bltal( #[rust_sitter::leaf(text = "bltal", transform = |s| s.to_string() )] String ),
+     Bnazal( #[rust_sitter::leaf(text = "bnazal", transform = |s| s.to_string() )] String ),
+     Sdns( #[rust_sitter::leaf(text = "sdns", transform = |s| s.to_string() )] String ),
+     Get( #[rust_sitter::leaf(text = "get", transform = |s| s.to_string() )] String ),
+     Jal( #[rust_sitter::leaf(text = "jal", transform = |s| s.to_string() )] String ),
+     Sb( #[rust_sitter::leaf(text = "sb", transform = |s| s.to_string() )] String ),
+     Bapal( #[rust_sitter::leaf(text = "bapal", transform = |s| s.to_string() )] String ),
+     Bgezal( #[rust_sitter::leaf(text = "bgezal", transform = |s| s.to_string() )] String ),
+     Breqz( #[rust_sitter::leaf(text = "breqz", transform = |s| s.to_string() )] String ),
+     Beqz( #[rust_sitter::leaf(text = "beqz", transform = |s| s.to_string() )] String ),
+     L( #[rust_sitter::leaf(text = "l", transform = |s| s.to_string() )] String ),
+     Sbn( #[rust_sitter::leaf(text = "sbn", transform = |s| s.to_string() )] String ),
+     S( #[rust_sitter::leaf(text = "s", transform = |s| s.to_string() )] String ),
+     Sapz( #[rust_sitter::leaf(text = "sapz", transform = |s| s.to_string() )] String ),
+     Bdns( #[rust_sitter::leaf(text = "bdns", transform = |s| s.to_string() )] String ),
+     Brge( #[rust_sitter::leaf(text = "brge", transform = |s| s.to_string() )] String ),
+}
--- a/ic10emu/src/grammar/ic10/logictypes.rs
+++ b/ic10emu/src/grammar/ic10/logictypes.rs
@@ -0,0 +1,284 @@
+// GENERATED CODE DO NOT MODIFY
+#[derive(PartialEq, Debug)]
+pub enum LogicType {
+     PressureInput2( #[rust_sitter::leaf(text = "PressureInput2", transform = |s| s.to_string() )] String ),
+     TotalMolesOutput2( #[rust_sitter::leaf(text = "TotalMolesOutput2", transform = |s| s.to_string() )] String ),
+     OperationalTemperatureEfficiency( #[rust_sitter::leaf(text = "OperationalTemperatureEfficiency", transform = |s| s.to_string() )] String ),
+     SolarIrradiance( #[rust_sitter::leaf(text = "SolarIrradiance", transform = |s| s.to_string() )] String ),
+     OverShootTarget( #[rust_sitter::leaf(text = "OverShootTarget", transform = |s| s.to_string() )] String ),
+     TemperatureSetting( #[rust_sitter::leaf(text = "TemperatureSetting", transform = |s| s.to_string() )] String ),
+     Harvest( #[rust_sitter::leaf(text = "Harvest", transform = |s| s.to_string() )] String ),
+     PlantEfficiency4( #[rust_sitter::leaf(text = "PlantEfficiency4", transform = |s| s.to_string() )] String ),
+     ExportQuantity( #[rust_sitter::leaf(text = "ExportQuantity", transform = |s| s.to_string() )] String ),
+     Activate( #[rust_sitter::leaf(text = "Activate", transform = |s| s.to_string() )] String ),
+     None( #[rust_sitter::leaf(text = "None", transform = |s| s.to_string() )] String ),
+     ElevatorSpeed( #[rust_sitter::leaf(text = "ElevatorSpeed", transform = |s| s.to_string() )] String ),
+     PressureSetting( #[rust_sitter::leaf(text = "PressureSetting", transform = |s| s.to_string() )] String ),
+     RatioNitrousOxide( #[rust_sitter::leaf(text = "RatioNitrousOxide", transform = |s| s.to_string() )] String ),
+     Reagents( #[rust_sitter::leaf(text = "Reagents", transform = |s| s.to_string() )] String ),
+     Vertical( #[rust_sitter::leaf(text = "Vertical", transform = |s| s.to_string() )] String ),
+     PositionY( #[rust_sitter::leaf(text = "PositionY", transform = |s| s.to_string() )] String ),
+     RatioOxygen( #[rust_sitter::leaf(text = "RatioOxygen", transform = |s| s.to_string() )] String ),
+     Sum( #[rust_sitter::leaf(text = "Sum", transform = |s| s.to_string() )] String ),
+     PressureOutput2( #[rust_sitter::leaf(text = "PressureOutput2", transform = |s| s.to_string() )] String ),
+     AutoLand( #[rust_sitter::leaf(text = "AutoLand", transform = |s| s.to_string() )] String ),
+     Channel6( #[rust_sitter::leaf(text = "Channel6", transform = |s| s.to_string() )] String ),
+     RatioOxygenOutput( #[rust_sitter::leaf(text = "RatioOxygenOutput", transform = |s| s.to_string() )] String ),
+     Acceleration( #[rust_sitter::leaf(text = "Acceleration", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrousOxideOutput2( #[rust_sitter::leaf(text = "RatioLiquidNitrousOxideOutput2", transform = |s| s.to_string() )] String ),
+     Contents( #[rust_sitter::leaf(text = "Contents", transform = |s| s.to_string() )] String ),
+     ImportQuantity( #[rust_sitter::leaf(text = "ImportQuantity", transform = |s| s.to_string() )] String ),
+     RatioWaterOutput( #[rust_sitter::leaf(text = "RatioWaterOutput", transform = |s| s.to_string() )] String ),
+     Color( #[rust_sitter::leaf(text = "Color", transform = |s| s.to_string() )] String ),
+     RatioNitrogenOutput( #[rust_sitter::leaf(text = "RatioNitrogenOutput", transform = |s| s.to_string() )] String ),
+     Temperature( #[rust_sitter::leaf(text = "Temperature", transform = |s| s.to_string() )] String ),
+     Setting( #[rust_sitter::leaf(text = "Setting", transform = |s| s.to_string() )] String ),
+     CompletionRatio( #[rust_sitter::leaf(text = "CompletionRatio", transform = |s| s.to_string() )] String ),
+     PlantHealth4( #[rust_sitter::leaf(text = "PlantHealth4", transform = |s| s.to_string() )] String ),
+     ReEntryAltitude( #[rust_sitter::leaf(text = "ReEntryAltitude", transform = |s| s.to_string() )] String ),
+     PositionZ( #[rust_sitter::leaf(text = "PositionZ", transform = |s| s.to_string() )] String ),
+     Stress( #[rust_sitter::leaf(text = "Stress", transform = |s| s.to_string() )] String ),
+     RatioLiquidOxygenOutput( #[rust_sitter::leaf(text = "RatioLiquidOxygenOutput", transform = |s| s.to_string() )] String ),
+     RatioNitrogenOutput2( #[rust_sitter::leaf(text = "RatioNitrogenOutput2", transform = |s| s.to_string() )] String ),
+     TargetY( #[rust_sitter::leaf(text = "TargetY", transform = |s| s.to_string() )] String ),
+     Health( #[rust_sitter::leaf(text = "Health", transform = |s| s.to_string() )] String ),
+     RatioCarbonDioxideOutput2( #[rust_sitter::leaf(text = "RatioCarbonDioxideOutput2", transform = |s| s.to_string() )] String ),
+     ImportCount( #[rust_sitter::leaf(text = "ImportCount", transform = |s| s.to_string() )] String ),
+     CelestialParentHash( #[rust_sitter::leaf(text = "CelestialParentHash", transform = |s| s.to_string() )] String ),
+     RatioNitrousOxideInput( #[rust_sitter::leaf(text = "RatioNitrousOxideInput", transform = |s| s.to_string() )] String ),
+     PowerPotential( #[rust_sitter::leaf(text = "PowerPotential", transform = |s| s.to_string() )] String ),
+     RatioLiquidPollutantOutput( #[rust_sitter::leaf(text = "RatioLiquidPollutantOutput", transform = |s| s.to_string() )] String ),
+     RatioSteamInput2( #[rust_sitter::leaf(text = "RatioSteamInput2", transform = |s| s.to_string() )] String ),
+     Volume( #[rust_sitter::leaf(text = "Volume", transform = |s| s.to_string() )] String ),
+     RatioLiquidPollutant( #[rust_sitter::leaf(text = "RatioLiquidPollutant", transform = |s| s.to_string() )] String ),
+     PowerActual( #[rust_sitter::leaf(text = "PowerActual", transform = |s| s.to_string() )] String ),
+     WorkingGasEfficiency( #[rust_sitter::leaf(text = "WorkingGasEfficiency", transform = |s| s.to_string() )] String ),
+     RatioOxygenInput2( #[rust_sitter::leaf(text = "RatioOxygenInput2", transform = |s| s.to_string() )] String ),
+     CombustionOutput( #[rust_sitter::leaf(text = "CombustionOutput", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrogenInput( #[rust_sitter::leaf(text = "RatioLiquidNitrogenInput", transform = |s| s.to_string() )] String ),
+     RatioWaterOutput2( #[rust_sitter::leaf(text = "RatioWaterOutput2", transform = |s| s.to_string() )] String ),
+     VelocityY( #[rust_sitter::leaf(text = "VelocityY", transform = |s| s.to_string() )] String ),
+     PlantHealth3( #[rust_sitter::leaf(text = "PlantHealth3", transform = |s| s.to_string() )] String ),
+     Open( #[rust_sitter::leaf(text = "Open", transform = |s| s.to_string() )] String ),
+     DestinationCode( #[rust_sitter::leaf(text = "DestinationCode", transform = |s| s.to_string() )] String ),
+     RecipeHash( #[rust_sitter::leaf(text = "RecipeHash", transform = |s| s.to_string() )] String ),
+     Average( #[rust_sitter::leaf(text = "Average", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrogen( #[rust_sitter::leaf(text = "RatioLiquidNitrogen", transform = |s| s.to_string() )] String ),
+     SettingInput( #[rust_sitter::leaf(text = "SettingInput", transform = |s| s.to_string() )] String ),
+     TemperatureDifferentialEfficiency( #[rust_sitter::leaf(text = "TemperatureDifferentialEfficiency", transform = |s| s.to_string() )] String ),
+     CombustionInput( #[rust_sitter::leaf(text = "CombustionInput", transform = |s| s.to_string() )] String ),
+     RatioCarbonDioxide( #[rust_sitter::leaf(text = "RatioCarbonDioxide", transform = |s| s.to_string() )] String ),
+     Filtration( #[rust_sitter::leaf(text = "Filtration", transform = |s| s.to_string() )] String ),
+     ForwardZ( #[rust_sitter::leaf(text = "ForwardZ", transform = |s| s.to_string() )] String ),
+     RequestHash( #[rust_sitter::leaf(text = "RequestHash", transform = |s| s.to_string() )] String ),
+     VelocityMagnitude( #[rust_sitter::leaf(text = "VelocityMagnitude", transform = |s| s.to_string() )] String ),
+     Channel1( #[rust_sitter::leaf(text = "Channel1", transform = |s| s.to_string() )] String ),
+     RatioSteam( #[rust_sitter::leaf(text = "RatioSteam", transform = |s| s.to_string() )] String ),
+     RatioSteamOutput( #[rust_sitter::leaf(text = "RatioSteamOutput", transform = |s| s.to_string() )] String ),
+     Channel2( #[rust_sitter::leaf(text = "Channel2", transform = |s| s.to_string() )] String ),
+     SortingClass( #[rust_sitter::leaf(text = "SortingClass", transform = |s| s.to_string() )] String ),
+     RatioOxygenOutput2( #[rust_sitter::leaf(text = "RatioOxygenOutput2", transform = |s| s.to_string() )] String ),
+     TargetPadIndex( #[rust_sitter::leaf(text = "TargetPadIndex", transform = |s| s.to_string() )] String ),
+     Required( #[rust_sitter::leaf(text = "Required", transform = |s| s.to_string() )] String ),
+     VelocityRelativeZ( #[rust_sitter::leaf(text = "VelocityRelativeZ", transform = |s| s.to_string() )] String ),
+     PassedMoles( #[rust_sitter::leaf(text = "PassedMoles", transform = |s| s.to_string() )] String ),
+     RatioLiquidVolatilesOutput2( #[rust_sitter::leaf(text = "RatioLiquidVolatilesOutput2", transform = |s| s.to_string() )] String ),
+     Class( #[rust_sitter::leaf(text = "Class", transform = |s| s.to_string() )] String ),
+     ForwardX( #[rust_sitter::leaf(text = "ForwardX", transform = |s| s.to_string() )] String ),
+     PlantHash4( #[rust_sitter::leaf(text = "PlantHash4", transform = |s| s.to_string() )] String ),
+     CollectableGoods( #[rust_sitter::leaf(text = "CollectableGoods", transform = |s| s.to_string() )] String ),
+     Combustion( #[rust_sitter::leaf(text = "Combustion", transform = |s| s.to_string() )] String ),
+     PlantGrowth1( #[rust_sitter::leaf(text = "PlantGrowth1", transform = |s| s.to_string() )] String ),
+     RatioLiquidOxygenOutput2( #[rust_sitter::leaf(text = "RatioLiquidOxygenOutput2", transform = |s| s.to_string() )] String ),
+     Bypass( #[rust_sitter::leaf(text = "Bypass", transform = |s| s.to_string() )] String ),
+     Occupied( #[rust_sitter::leaf(text = "Occupied", transform = |s| s.to_string() )] String ),
+     VolumeOfLiquid( #[rust_sitter::leaf(text = "VolumeOfLiquid", transform = |s| s.to_string() )] String ),
+     RatioNitrogen( #[rust_sitter::leaf(text = "RatioNitrogen", transform = |s| s.to_string() )] String ),
+     ExportCount( #[rust_sitter::leaf(text = "ExportCount", transform = |s| s.to_string() )] String ),
+     AlignmentError( #[rust_sitter::leaf(text = "AlignmentError", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrogenOutput2( #[rust_sitter::leaf(text = "RatioLiquidNitrogenOutput2", transform = |s| s.to_string() )] String ),
+     RatioLiquidOxygen( #[rust_sitter::leaf(text = "RatioLiquidOxygen", transform = |s| s.to_string() )] String ),
+     ThrustToWeight( #[rust_sitter::leaf(text = "ThrustToWeight", transform = |s| s.to_string() )] String ),
+     TargetZ( #[rust_sitter::leaf(text = "TargetZ", transform = |s| s.to_string() )] String ),
+     SettingInputHash( #[rust_sitter::leaf(text = "SettingInputHash", transform = |s| s.to_string() )] String ),
+     PlantGrowth2( #[rust_sitter::leaf(text = "PlantGrowth2", transform = |s| s.to_string() )] String ),
+     WattsReachingContact( #[rust_sitter::leaf(text = "WattsReachingContact", transform = |s| s.to_string() )] String ),
+     SoundAlert( #[rust_sitter::leaf(text = "SoundAlert", transform = |s| s.to_string() )] String ),
+     CombustionInput2( #[rust_sitter::leaf(text = "CombustionInput2", transform = |s| s.to_string() )] String ),
+     DistanceAu( #[rust_sitter::leaf(text = "DistanceAu", transform = |s| s.to_string() )] String ),
+     SizeY( #[rust_sitter::leaf(text = "SizeY", transform = |s| s.to_string() )] String ),
+     Power( #[rust_sitter::leaf(text = "Power", transform = |s| s.to_string() )] String ),
+     PressureInput( #[rust_sitter::leaf(text = "PressureInput", transform = |s| s.to_string() )] String ),
+     RatioNitrousOxideOutput2( #[rust_sitter::leaf(text = "RatioNitrousOxideOutput2", transform = |s| s.to_string() )] String ),
+     PlantHash3( #[rust_sitter::leaf(text = "PlantHash3", transform = |s| s.to_string() )] String ),
+     Horizontal( #[rust_sitter::leaf(text = "Horizontal", transform = |s| s.to_string() )] String ),
+     PlantGrowth3( #[rust_sitter::leaf(text = "PlantGrowth3", transform = |s| s.to_string() )] String ),
+     Minimum( #[rust_sitter::leaf(text = "Minimum", transform = |s| s.to_string() )] String ),
+     ExportSlotHash( #[rust_sitter::leaf(text = "ExportSlotHash", transform = |s| s.to_string() )] String ),
+     SolarConstant( #[rust_sitter::leaf(text = "SolarConstant", transform = |s| s.to_string() )] String ),
+     PlantHash1( #[rust_sitter::leaf(text = "PlantHash1", transform = |s| s.to_string() )] String ),
+     ChargeRatio( #[rust_sitter::leaf(text = "ChargeRatio", transform = |s| s.to_string() )] String ),
+     RatioLiquidCarbonDioxideOutput2( #[rust_sitter::leaf(text = "RatioLiquidCarbonDioxideOutput2", transform = |s| s.to_string() )] String ),
+     PressureExternal( #[rust_sitter::leaf(text = "PressureExternal", transform = |s| s.to_string() )] String ),
+     Mass( #[rust_sitter::leaf(text = "Mass", transform = |s| s.to_string() )] String ),
+     PressureOutput( #[rust_sitter::leaf(text = "PressureOutput", transform = |s| s.to_string() )] String ),
+     PlantEfficiency3( #[rust_sitter::leaf(text = "PlantEfficiency3", transform = |s| s.to_string() )] String ),
+     RatioLiquidPollutantInput( #[rust_sitter::leaf(text = "RatioLiquidPollutantInput", transform = |s| s.to_string() )] String ),
+     AirRelease( #[rust_sitter::leaf(text = "AirRelease", transform = |s| s.to_string() )] String ),
+     RatioWaterInput2( #[rust_sitter::leaf(text = "RatioWaterInput2", transform = |s| s.to_string() )] String ),
+     ReferenceId( #[rust_sitter::leaf(text = "ReferenceId", transform = |s| s.to_string() )] String ),
+     FlightControlRule( #[rust_sitter::leaf(text = "FlightControlRule", transform = |s| s.to_string() )] String ),
+     VerticalRatio( #[rust_sitter::leaf(text = "VerticalRatio", transform = |s| s.to_string() )] String ),
+     Throttle( #[rust_sitter::leaf(text = "Throttle", transform = |s| s.to_string() )] String ),
+     Index( #[rust_sitter::leaf(text = "Index", transform = |s| s.to_string() )] String ),
+     RatioLiquidCarbonDioxideInput( #[rust_sitter::leaf(text = "RatioLiquidCarbonDioxideInput", transform = |s| s.to_string() )] String ),
+     Rpm( #[rust_sitter::leaf(text = "Rpm", transform = |s| s.to_string() )] String ),
+     Channel5( #[rust_sitter::leaf(text = "Channel5", transform = |s| s.to_string() )] String ),
+     Progress( #[rust_sitter::leaf(text = "Progress", transform = |s| s.to_string() )] String ),
+     DryMass( #[rust_sitter::leaf(text = "DryMass", transform = |s| s.to_string() )] String ),
+     Output( #[rust_sitter::leaf(text = "Output", transform = |s| s.to_string() )] String ),
+     OrbitPeriod( #[rust_sitter::leaf(text = "OrbitPeriod", transform = |s| s.to_string() )] String ),
+     RatioPollutantInput( #[rust_sitter::leaf(text = "RatioPollutantInput", transform = |s| s.to_string() )] String ),
+     EnvironmentEfficiency( #[rust_sitter::leaf(text = "EnvironmentEfficiency", transform = |s| s.to_string() )] String ),
+     NextWeatherEventTime( #[rust_sitter::leaf(text = "NextWeatherEventTime", transform = |s| s.to_string() )] String ),
+     RatioCarbonDioxideInput2( #[rust_sitter::leaf(text = "RatioCarbonDioxideInput2", transform = |s| s.to_string() )] String ),
+     MineablesInQueue( #[rust_sitter::leaf(text = "MineablesInQueue", transform = |s| s.to_string() )] String ),
+     SizeZ( #[rust_sitter::leaf(text = "SizeZ", transform = |s| s.to_string() )] String ),
+     RatioLiquidOxygenInput( #[rust_sitter::leaf(text = "RatioLiquidOxygenInput", transform = |s| s.to_string() )] String ),
+     TemperatureInput2( #[rust_sitter::leaf(text = "TemperatureInput2", transform = |s| s.to_string() )] String ),
+     TemperatureOutput( #[rust_sitter::leaf(text = "TemperatureOutput", transform = |s| s.to_string() )] String ),
+     Lock( #[rust_sitter::leaf(text = "Lock", transform = |s| s.to_string() )] String ),
+     DrillCondition( #[rust_sitter::leaf(text = "DrillCondition", transform = |s| s.to_string() )] String ),
+     Unknown( #[rust_sitter::leaf(text = "Unknown", transform = |s| s.to_string() )] String ),
+     RatioLiquidCarbonDioxide( #[rust_sitter::leaf(text = "RatioLiquidCarbonDioxide", transform = |s| s.to_string() )] String ),
+     Channel( #[rust_sitter::leaf(text = "Channel", transform = |s| s.to_string() )] String ),
+     RatioLiquidVolatilesInput2( #[rust_sitter::leaf(text = "RatioLiquidVolatilesInput2", transform = |s| s.to_string() )] String ),
+     PlantEfficiency2( #[rust_sitter::leaf(text = "PlantEfficiency2", transform = |s| s.to_string() )] String ),
+     ImportSlotHash( #[rust_sitter::leaf(text = "ImportSlotHash", transform = |s| s.to_string() )] String ),
+     RatioPollutantInput2( #[rust_sitter::leaf(text = "RatioPollutantInput2", transform = |s| s.to_string() )] String ),
+     RatioPollutantOutput2( #[rust_sitter::leaf(text = "RatioPollutantOutput2", transform = |s| s.to_string() )] String ),
+     PlantGrowth4( #[rust_sitter::leaf(text = "PlantGrowth4", transform = |s| s.to_string() )] String ),
+     MinimumWattsToContact( #[rust_sitter::leaf(text = "MinimumWattsToContact", transform = |s| s.to_string() )] String ),
+     RatioLiquidCarbonDioxideOutput( #[rust_sitter::leaf(text = "RatioLiquidCarbonDioxideOutput", transform = |s| s.to_string() )] String ),
+     Ratio( #[rust_sitter::leaf(text = "Ratio", transform = |s| s.to_string() )] String ),
+     RatioVolatiles( #[rust_sitter::leaf(text = "RatioVolatiles", transform = |s| s.to_string() )] String ),
+     RatioWater( #[rust_sitter::leaf(text = "RatioWater", transform = |s| s.to_string() )] String ),
+     Fuel( #[rust_sitter::leaf(text = "Fuel", transform = |s| s.to_string() )] String ),
+     PowerGeneration( #[rust_sitter::leaf(text = "PowerGeneration", transform = |s| s.to_string() )] String ),
+     RatioLiquidVolatilesOutput( #[rust_sitter::leaf(text = "RatioLiquidVolatilesOutput", transform = |s| s.to_string() )] String ),
+     VelocityRelativeX( #[rust_sitter::leaf(text = "VelocityRelativeX", transform = |s| s.to_string() )] String ),
+     RatioVolatilesOutput( #[rust_sitter::leaf(text = "RatioVolatilesOutput", transform = |s| s.to_string() )] String ),
+     CombustionOutput2( #[rust_sitter::leaf(text = "CombustionOutput2", transform = |s| s.to_string() )] String ),
+     Efficiency( #[rust_sitter::leaf(text = "Efficiency", transform = |s| s.to_string() )] String ),
+     VelocityRelativeY( #[rust_sitter::leaf(text = "VelocityRelativeY", transform = |s| s.to_string() )] String ),
+     Weight( #[rust_sitter::leaf(text = "Weight", transform = |s| s.to_string() )] String ),
+     RatioCarbonDioxideOutput( #[rust_sitter::leaf(text = "RatioCarbonDioxideOutput", transform = |s| s.to_string() )] String ),
+     PlantHash2( #[rust_sitter::leaf(text = "PlantHash2", transform = |s| s.to_string() )] String ),
+     PlantEfficiency1( #[rust_sitter::leaf(text = "PlantEfficiency1", transform = |s| s.to_string() )] String ),
+     RatioNitrousOxideOutput( #[rust_sitter::leaf(text = "RatioNitrousOxideOutput", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrogenOutput( #[rust_sitter::leaf(text = "RatioLiquidNitrogenOutput", transform = |s| s.to_string() )] String ),
+     RatioVolatilesInput2( #[rust_sitter::leaf(text = "RatioVolatilesInput2", transform = |s| s.to_string() )] String ),
+     ManualResearchRequiredPod( #[rust_sitter::leaf(text = "ManualResearchRequiredPod", transform = |s| s.to_string() )] String ),
+     MinWattsToContact( #[rust_sitter::leaf(text = "MinWattsToContact", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrogenInput2( #[rust_sitter::leaf(text = "RatioLiquidNitrogenInput2", transform = |s| s.to_string() )] String ),
+     Channel0( #[rust_sitter::leaf(text = "Channel0", transform = |s| s.to_string() )] String ),
+     SolarAngle( #[rust_sitter::leaf(text = "SolarAngle", transform = |s| s.to_string() )] String ),
+     PressureAir( #[rust_sitter::leaf(text = "PressureAir", transform = |s| s.to_string() )] String ),
+     Orientation( #[rust_sitter::leaf(text = "Orientation", transform = |s| s.to_string() )] String ),
+     HorizontalRatio( #[rust_sitter::leaf(text = "HorizontalRatio", transform = |s| s.to_string() )] String ),
+     RatioLiquidPollutantInput2( #[rust_sitter::leaf(text = "RatioLiquidPollutantInput2", transform = |s| s.to_string() )] String ),
+     PowerRequired( #[rust_sitter::leaf(text = "PowerRequired", transform = |s| s.to_string() )] String ),
+     SettingOutputHash( #[rust_sitter::leaf(text = "SettingOutputHash", transform = |s| s.to_string() )] String ),
+     OccupantHash( #[rust_sitter::leaf(text = "OccupantHash", transform = |s| s.to_string() )] String ),
+     TotalMolesInput( #[rust_sitter::leaf(text = "TotalMolesInput", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrousOxide( #[rust_sitter::leaf(text = "RatioLiquidNitrousOxide", transform = |s| s.to_string() )] String ),
+     RatioCarbonDioxideInput( #[rust_sitter::leaf(text = "RatioCarbonDioxideInput", transform = |s| s.to_string() )] String ),
+     RatioLiquidCarbonDioxideInput2( #[rust_sitter::leaf(text = "RatioLiquidCarbonDioxideInput2", transform = |s| s.to_string() )] String ),
+     RatioOxygenInput( #[rust_sitter::leaf(text = "RatioOxygenInput", transform = |s| s.to_string() )] String ),
+     VelocityZ( #[rust_sitter::leaf(text = "VelocityZ", transform = |s| s.to_string() )] String ),
+     RatioNitrogenInput2( #[rust_sitter::leaf(text = "RatioNitrogenInput2", transform = |s| s.to_string() )] String ),
+     TemperatureExternal( #[rust_sitter::leaf(text = "TemperatureExternal", transform = |s| s.to_string() )] String ),
+     PositionX( #[rust_sitter::leaf(text = "PositionX", transform = |s| s.to_string() )] String ),
+     Mode( #[rust_sitter::leaf(text = "Mode", transform = |s| s.to_string() )] String ),
+     TemperatureInput( #[rust_sitter::leaf(text = "TemperatureInput", transform = |s| s.to_string() )] String ),
+     InterrogationProgress( #[rust_sitter::leaf(text = "InterrogationProgress", transform = |s| s.to_string() )] String ),
+     PressureInternal( #[rust_sitter::leaf(text = "PressureInternal", transform = |s| s.to_string() )] String ),
+     PrefabHash( #[rust_sitter::leaf(text = "PrefabHash", transform = |s| s.to_string() )] String ),
+     Seeding( #[rust_sitter::leaf(text = "Seeding", transform = |s| s.to_string() )] String ),
+     EntityState( #[rust_sitter::leaf(text = "EntityState", transform = |s| s.to_string() )] String ),
+     Maximum( #[rust_sitter::leaf(text = "Maximum", transform = |s| s.to_string() )] String ),
+     RatioLiquidPollutantOutput2( #[rust_sitter::leaf(text = "RatioLiquidPollutantOutput2", transform = |s| s.to_string() )] String ),
+     RequiredPower( #[rust_sitter::leaf(text = "RequiredPower", transform = |s| s.to_string() )] String ),
+     RatioNitrogenInput( #[rust_sitter::leaf(text = "RatioNitrogenInput", transform = |s| s.to_string() )] String ),
+     TargetX( #[rust_sitter::leaf(text = "TargetX", transform = |s| s.to_string() )] String ),
+     RatioLiquidOxygenInput2( #[rust_sitter::leaf(text = "RatioLiquidOxygenInput2", transform = |s| s.to_string() )] String ),
+     Channel4( #[rust_sitter::leaf(text = "Channel4", transform = |s| s.to_string() )] String ),
+     Bpm( #[rust_sitter::leaf(text = "Bpm", transform = |s| s.to_string() )] String ),
+     ExportSlotOccupant( #[rust_sitter::leaf(text = "ExportSlotOccupant", transform = |s| s.to_string() )] String ),
+     RatioPollutantOutput( #[rust_sitter::leaf(text = "RatioPollutantOutput", transform = |s| s.to_string() )] String ),
+     SemiMajorAxis( #[rust_sitter::leaf(text = "SemiMajorAxis", transform = |s| s.to_string() )] String ),
+     ContactTypeId( #[rust_sitter::leaf(text = "ContactTypeId", transform = |s| s.to_string() )] String ),
+     Error( #[rust_sitter::leaf(text = "Error", transform = |s| s.to_string() )] String ),
+     LineNumber( #[rust_sitter::leaf(text = "LineNumber", transform = |s| s.to_string() )] String ),
+     ForceWrite( #[rust_sitter::leaf(text = "ForceWrite", transform = |s| s.to_string() )] String ),
+     Pressure( #[rust_sitter::leaf(text = "Pressure", transform = |s| s.to_string() )] String ),
+     SignalStrength( #[rust_sitter::leaf(text = "SignalStrength", transform = |s| s.to_string() )] String ),
+     VelocityX( #[rust_sitter::leaf(text = "VelocityX", transform = |s| s.to_string() )] String ),
+     RatioPollutant( #[rust_sitter::leaf(text = "RatioPollutant", transform = |s| s.to_string() )] String ),
+     AutoShutOff( #[rust_sitter::leaf(text = "AutoShutOff", transform = |s| s.to_string() )] String ),
+     CombustionLimiter( #[rust_sitter::leaf(text = "CombustionLimiter", transform = |s| s.to_string() )] String ),
+     SizeX( #[rust_sitter::leaf(text = "SizeX", transform = |s| s.to_string() )] String ),
+     Thrust( #[rust_sitter::leaf(text = "Thrust", transform = |s| s.to_string() )] String ),
+     ForwardY( #[rust_sitter::leaf(text = "ForwardY", transform = |s| s.to_string() )] String ),
+     RatioLiquidVolatilesInput( #[rust_sitter::leaf(text = "RatioLiquidVolatilesInput", transform = |s| s.to_string() )] String ),
+     ImportSlotOccupant( #[rust_sitter::leaf(text = "ImportSlotOccupant", transform = |s| s.to_string() )] String ),
+     TotalMolesInput2( #[rust_sitter::leaf(text = "TotalMolesInput2", transform = |s| s.to_string() )] String ),
+     Quantity( #[rust_sitter::leaf(text = "Quantity", transform = |s| s.to_string() )] String ),
+     RatioLiquidVolatiles( #[rust_sitter::leaf(text = "RatioLiquidVolatiles", transform = |s| s.to_string() )] String ),
+     Growth( #[rust_sitter::leaf(text = "Growth", transform = |s| s.to_string() )] String ),
+     Mature( #[rust_sitter::leaf(text = "Mature", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrousOxideInput2( #[rust_sitter::leaf(text = "RatioLiquidNitrousOxideInput2", transform = |s| s.to_string() )] String ),
+     RatioVolatilesOutput2( #[rust_sitter::leaf(text = "RatioVolatilesOutput2", transform = |s| s.to_string() )] String ),
+     PressureEfficiency( #[rust_sitter::leaf(text = "PressureEfficiency", transform = |s| s.to_string() )] String ),
+     ElevatorLevel( #[rust_sitter::leaf(text = "ElevatorLevel", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrousOxideInput( #[rust_sitter::leaf(text = "RatioLiquidNitrousOxideInput", transform = |s| s.to_string() )] String ),
+     MaxQuantity( #[rust_sitter::leaf(text = "MaxQuantity", transform = |s| s.to_string() )] String ),
+     Flush( #[rust_sitter::leaf(text = "Flush", transform = |s| s.to_string() )] String ),
+     RatioLiquidNitrousOxideOutput( #[rust_sitter::leaf(text = "RatioLiquidNitrousOxideOutput", transform = |s| s.to_string() )] String ),
+     Channel7( #[rust_sitter::leaf(text = "Channel7", transform = |s| s.to_string() )] String ),
+     CelestialHash( #[rust_sitter::leaf(text = "CelestialHash", transform = |s| s.to_string() )] String ),
+     RatioSteamInput( #[rust_sitter::leaf(text = "RatioSteamInput", transform = |s| s.to_string() )] String ),
+     Damage( #[rust_sitter::leaf(text = "Damage", transform = |s| s.to_string() )] String ),
+     Apex( #[rust_sitter::leaf(text = "Apex", transform = |s| s.to_string() )] String ),
+     ReturnFuelCost( #[rust_sitter::leaf(text = "ReturnFuelCost", transform = |s| s.to_string() )] String ),
+     ExhaustVelocity( #[rust_sitter::leaf(text = "ExhaustVelocity", transform = |s| s.to_string() )] String ),
+     RatioWaterInput( #[rust_sitter::leaf(text = "RatioWaterInput", transform = |s| s.to_string() )] String ),
+     SettingOutput( #[rust_sitter::leaf(text = "SettingOutput", transform = |s| s.to_string() )] String ),
+     TrueAnomaly( #[rust_sitter::leaf(text = "TrueAnomaly", transform = |s| s.to_string() )] String ),
+     BurnTimeRemaining( #[rust_sitter::leaf(text = "BurnTimeRemaining", transform = |s| s.to_string() )] String ),
+     CurrentResearchPodType( #[rust_sitter::leaf(text = "CurrentResearchPodType", transform = |s| s.to_string() )] String ),
+     Recipe( #[rust_sitter::leaf(text = "Recipe", transform = |s| s.to_string() )] String ),
+     On( #[rust_sitter::leaf(text = "On", transform = |s| s.to_string() )] String ),
+     PressureWaste( #[rust_sitter::leaf(text = "PressureWaste", transform = |s| s.to_string() )] String ),
+     Inclination( #[rust_sitter::leaf(text = "Inclination", transform = |s| s.to_string() )] String ),
+     SignalId( #[rust_sitter::leaf(text = "SignalID", transform = |s| s.to_string() )] String ),
+     Plant( #[rust_sitter::leaf(text = "Plant", transform = |s| s.to_string() )] String ),
+     RatioNitrousOxideInput2( #[rust_sitter::leaf(text = "RatioNitrousOxideInput2", transform = |s| s.to_string() )] String ),
+     Idle( #[rust_sitter::leaf(text = "Idle", transform = |s| s.to_string() )] String ),
+     TemperatureOutput2( #[rust_sitter::leaf(text = "TemperatureOutput2", transform = |s| s.to_string() )] String ),
+     MineablesInVicinity( #[rust_sitter::leaf(text = "MineablesInVicinity", transform = |s| s.to_string() )] String ),
+     Channel3( #[rust_sitter::leaf(text = "Channel3", transform = |s| s.to_string() )] String ),
+     Charge( #[rust_sitter::leaf(text = "Charge", transform = |s| s.to_string() )] String ),
+     RatioVolatilesInput( #[rust_sitter::leaf(text = "RatioVolatilesInput", transform = |s| s.to_string() )] String ),
+     Time( #[rust_sitter::leaf(text = "Time", transform = |s| s.to_string() )] String ),
+     TotalMolesOutput( #[rust_sitter::leaf(text = "TotalMolesOutput", transform = |s| s.to_string() )] String ),
+     FilterType( #[rust_sitter::leaf(text = "FilterType", transform = |s| s.to_string() )] String ),
+     TotalMoles( #[rust_sitter::leaf(text = "TotalMoles", transform = |s| s.to_string() )] String ),
+     Eccentricity( #[rust_sitter::leaf(text = "Eccentricity", transform = |s| s.to_string() )] String ),
+     PlantHealth1( #[rust_sitter::leaf(text = "PlantHealth1", transform = |s| s.to_string() )] String ),
+     TimeToDestination( #[rust_sitter::leaf(text = "TimeToDestination", transform = |s| s.to_string() )] String ),
+     RatioSteamOutput2( #[rust_sitter::leaf(text = "RatioSteamOutput2", transform = |s| s.to_string() )] String ),
+     PlantHealth2( #[rust_sitter::leaf(text = "PlantHealth2", transform = |s| s.to_string() )] String ),
+     DistanceKm( #[rust_sitter::leaf(text = "DistanceKm", transform = |s| s.to_string() )] String ),
+     ClearMemory( #[rust_sitter::leaf(text = "ClearMemory", transform = |s| s.to_string() )] String ),
+}
--- a/ic10emu/src/grammar/rich_types.rs
+++ b/ic10emu/src/grammar/rich_types.rs
@@ -0,0 +1,81 @@
+
+#[derive(PartialEq, Debug)]
+pub struct Register {
+    pub indirection: u32,
+    pub target: u32,
+}
+
+impl Register {
+    pub fn from_str(rs: &str) -> Self {
+        match &rs[..2] {
+            "sp" => Register {
+                indirection: 0,
+                target: 16,
+            },
+            "ra" => Register {
+                indirection: 0,
+                target: 17,
+            },
+            _ => Register {
+                indirection: rs[1..].chars().filter(|c| c == &'r').count() as u32,
+                target: rs[1..].replace("r", "").parse().unwrap(),
+            },
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub struct DeviceSpec {
+    pub device: Device,
+    pub channel: Option<u32>,
+}
+
+impl DeviceSpec {
+    pub fn from_str(ds: &str) -> Self {
+        let mut parts = ds.split(":");
+        let d = parts.next().unwrap();
+        let channel: Option<u32> = parts.next().map(|c| c.parse().unwrap());
+
+        match d.as_bytes()[1] as char {
+            'b' => DeviceSpec {
+                device: Device::Db,
+                channel,
+            },
+            '0'..='9' => DeviceSpec {
+                device: Device::Numbered(d[1..2].parse().unwrap()),
+                channel,
+            },
+            'r' => DeviceSpec {
+                device: Device::Indirect(Register {
+                    indirection: d[2..].chars().filter(|c| c == &'r').count() as u32,
+                    target: d[2..].replace("r", "").parse().unwrap(),
+                }),
+                channel,
+            },
+            c => panic!("Bad second char in device spec '{}'", c),
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub enum Device {
+    Db,
+    Numbered(u32),
+    Indirect(Register),
+}
+
+#[derive(PartialEq, Debug)]
+pub struct HashString {
+    pub string: String,
+    pub hash: i32,
+}
+
+impl HashString {
+    pub fn from_str(s: &str) -> Self {
+        let crc = const_crc32::crc32(s.as_bytes()) as i32;
+        HashString {
+            string: s.to_string(),
+            hash: crc,
+        }
+    }
+}
--- a/ic10emu/src/lib.rs
+++ b/ic10emu/src/lib.rs
@@ -1,28 +1,148 @@
-#[allow(dead_code)]
+use core::f64;
+use std::collections::{HashMap, HashSet};
+
+mod grammar;
+mod compiler;
+
+
 #[derive(Debug)]
-pub struct VM {
-    ip: u8,
-    ra: f64,
-    registers: [f64; 16], // r[0-15]
-    sp: f64,
-    stack: [f64; 512],
+pub enum FieldType {
+    Read,
+    Write,
+    ReadWrite
 }

-impl Default for VM {
+#[derive(Debug)]
+pub struct LogicField {
+    field_type: FieldType,
+    value: f64,
+
+}
+
+#[derive(Debug, Default)]
+pub struct GenericDevice {
+    pub id: u16,
+    pub fields: HashMap<u8, LogicField>,
+}
+
+#[derive(Debug)]
+enum Device {
+    IC(IC),
+    Generic(GenericDevice),
+}
+
+#[derive(Debug)]
+pub struct IC {
+    pub id: u16,
+    pub ip: u8,
+    pub registers: [f64; 18], // r[0-15]
+    pub stack: [f64; 512],
+    pub pins: [Option<u16>; 6],
+    pub fields: HashMap<u8, LogicField>,
+}
+
+#[derive(Debug)]
+pub struct Network {
+    pub devices: HashSet<u16>,
+    pub channels: [f64; 8],
+}
+
+#[derive(Debug)]
+struct IdSequenceGenerator {
+    next: u16,
+}
+
+impl Default for IdSequenceGenerator {
    fn default() -> Self {
-        VM {
-            ip: 0,
-            ra: 0.0,
-            registers: [0.0; 16],
-            sp: 0.0,
-            stack: [0.0; 512],
+        IdSequenceGenerator { next: 1 }
+    }
+}
+
+impl IdSequenceGenerator {
+    pub fn next(&mut self) -> u16 {
+        let val = self.next;
+        self.next += 1;
+        val
+    }
+}
+
+#[derive(Debug)]
+pub struct VM {
+    pub ics: HashSet<u16>,
+    pub devices: HashMap<u16, Device>,
+    pub networks: Vec<Network>,
+    id_gen: IdSequenceGenerator,
+}
+
+impl Default for Network {
+    fn default() -> Self {
+        Network {
+            devices: HashSet::new(),
+            channels: [f64::NAN; 8],
+        }
+    }
+}
+
+impl IC {
+    pub fn new(id: u16) -> Self {
+        IC {
+            id,
+            ip: 0,
+            registers: [0.0; 18],
+            stack: [0.0; 512],
+            pins: [None; 6],
+            fields: HashMap::new(),
+        }
+    }
+}
+
+impl GenericDevice {
+    pub fn new(id: u16) -> Self {
+        GenericDevice {
+            id,
+            fields: HashMap::new(),
+        }
+    }
+}
+
+impl Device {
+    pub fn id(&self) -> u16 {
+        match self {
+            Self::IC(ic) => ic.id,
+            Self::Generic(d) => d.id,
        }
    }
-    
 }

 impl VM {
-    pub fn new() -> VM {
-        VM::default()
+    pub fn new() -> Self {
+        let id_gen = IdSequenceGenerator::default();
+        let default_network = Network::default();
+        let mut vm = VM {
+            ics: HashSet::new(),
+            devices: HashMap::new(),
+            networks: vec![default_network],
+            id_gen,
+        };
+        let ic = vm.new_ic();
+        vm.add_ic(ic);
+        vm
    }
+
+    pub fn new_ic(&mut self) -> IC {
+        IC::new(self.id_gen.next())
+    }
+
+    pub fn add_ic(&mut self, ic: IC) {
+        let device = Device::IC(ic);
+        self.ics.insert(device.id());
+        self.devices.insert(device.id(), device);
+    }
+
+    pub fn remove_ic(&mut self, id: u16) {
+        if  self.ics.remove(&id) {
+            self.devices.remove(&id);
+        }
+    }
+
 }
--- a/ic10emu/stationpedia.py
+++ b/ic10emu/stationpedia.py
@@ -0,0 +1,19 @@
+import json
+from pathlib import Path
+from pprint import pprint
+
+def extract_logicable():
+    logicable = []
+    pedia = {}
+    with Path("./FullStationpedia.json").open("r") as f:
+        pedia.update(json.load(f))
+    for page in pedia["pages"]:
+        if page["LogicInsert"] or page["LogicSlotInsert"]:
+            logicable.append(page)
+    print(f"{len(logicable)} of {len(pedia["pages"])} are logicable")
+
+
+
+
+if __name__ == "__main__":
+    extract_logicable()
--- a/ic10lsp_wasm/Cargo.lock
+++ b/ic10lsp_wasm/Cargo.lock
@@ -395,7 +395,7 @@ checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
 [[package]]
 name = "ic10lsp"
 version = "0.7.4"
-source = "git+https://github.com/Ryex/ic10lsp.git?branch=wasm#74e948ad3d3f0d220b4ab258525afcd1b8a1548b"
+source = "git+https://github.com/Ryex/ic10lsp.git?branch=wasm#b6300c0bfd55feab487c180582b4005d6bb85bbd"
 dependencies = [
 "clap",
 "const-crc32",