diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
new file mode 100644
index 0000000..1d3b680
--- /dev/null
+++ b/.github/workflows/test.yaml
@@ -0,0 +1,23 @@
+name: Cargo Build & Test
+
+on:
+  push:
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build_and_test:
+    name: Rust project - latest
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain:
+          - stable
+          - beta
+          - nightly
+    steps:
+      - uses: actions/checkout@v4
+      - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
+      - run: cargo test --verbose
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 3fd8149..9647c4b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bin2ml"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 
 [dependencies]
@@ -36,6 +36,9 @@ features = ["serde-1"]
 inference = ["dep:tch"]
 goblin = ["dep:goblin"]
 
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(inference)'] }
+
 #https://github.com/johnthagen/min-sized-rust
 [profile.release]
 lto = true
diff --git a/src/agfj.rs b/src/agfj.rs
index 1ba45f8..3bcf843 100644
--- a/src/agfj.rs
+++ b/src/agfj.rs
@@ -376,6 +376,7 @@ impl AGFJFunc {
                         info!("Invalid Feature Type. Skipping..");
                         return;
                     }
+                    FeatureType::Pcode => StringOrF64::String(Vec::new()),
                 };
 
                 let min_offset: u64 = self.offset;
@@ -412,6 +413,7 @@ impl AGFJFunc {
                         info!("Invalid Feature Type. Skipping..");
                         return;
                     }
+                    _ => {}
                 };
 
                 if !edge_list.is_empty() {
diff --git a/src/bb.rs b/src/bb.rs
index 7a325b4..24bf818 100644
--- a/src/bb.rs
+++ b/src/bb.rs
@@ -24,6 +24,7 @@ pub enum FeatureType {
     ModelEmbedded,
     Encoded,
     Invalid,
+    Pcode,
 }
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
diff --git a/src/combos.rs b/src/combos.rs
index 3aebb81..f2d675f 100644
--- a/src/combos.rs
+++ b/src/combos.rs
@@ -41,8 +41,6 @@ pub enum ComboFileTypes {
 #[derive(Debug)]
 pub struct ComboJob {
     pub combo_type: ComboTypes,
-    pub file_type_one: ComboFileTypes,
-    pub file_type_two: ComboFileTypes,
     pub input_path: PathBuf,
     pub output_path: PathBuf,
 }
@@ -53,11 +51,8 @@ impl ComboJob {
         let combo_file_types = combo_type.to_combo_file_types();
 
         if combo_file_types.is_ok() {
-            let combo_file_types = combo_file_types.unwrap();
             Ok(ComboJob {
                 combo_type,
-                file_type_one: combo_file_types.0,
-                file_type_two: combo_file_types.1,
                 input_path: input_path.to_path_buf(),
                 output_path: output_path.to_path_buf(),
             })
diff --git a/src/consts.rs b/src/consts.rs
index 575d211..18fa9b5 100644
--- a/src/consts.rs
+++ b/src/consts.rs
@@ -47,7 +47,7 @@ pub const GENERAL_PURPOSE_32_BIT_REGS: [&str; 165] = [
     "f21", "f22", "f23", "f24", "f25", "f26", "f27", "f29", "f30", "f31", "v0", "v1", "a0", "a1",
     "a2", "a3", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "t8", "t9", "s0",
 ];
-// MIPS registers are normalised to 32 bit always - This is becuase the name of the registers
+// MIPS registers are normalised to 32 bit always - This is because the name of the registers
 // is always the same regardless of architecture - Different to x86/x64.
 pub const GENERAL_PURPOSE_64_BIT_REGS: [&str; 75] = [
     "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "x11", "x12", "x13", "x14",
diff --git a/src/dedup.rs b/src/dedup.rs
index 0a1933a..356b0c5 100644
--- a/src/dedup.rs
+++ b/src/dedup.rs
@@ -332,6 +332,8 @@ impl CGCorpus {
             }
         }
 
+        filepaths.sort_unstable();
+
         info!("Returning One Hop CG Corpus Struct");
         let output_path = output_path.to_owned();
 
diff --git a/src/extract.rs b/src/extract.rs
index 7e4008a..edfad28 100644
--- a/src/extract.rs
+++ b/src/extract.rs
@@ -286,7 +286,7 @@ pub struct BasicBlockMetadataEntry {
     pub size: u64,
     pub jump: Option<u64>,
     pub fail: Option<u64>,
-    pub opaddr: f64,
+    pub opaddr: u64,
     pub inputs: u64,
     pub outputs: u64,
     pub ninstr: u64,
diff --git a/src/main.rs b/src/main.rs
index 82802dd..f9e3a59 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -114,7 +114,7 @@ enum GenerateSubCommands {
         output_path: PathBuf,
 
         /// The type of features to generate per basic block (node)
-        #[arg(short, long, value_name = "FEATURE_TYPE", value_parser = clap::builder::PossibleValuesParser::new(["gemini", "discovre", "dgis", "tiknib", "disasm", "esil"])
+        #[arg(short, long, value_name = "FEATURE_TYPE", value_parser = clap::builder::PossibleValuesParser::new(["gemini", "discovre", "dgis", "tiknib", "disasm", "esil", "pcode"])
         .map(|s| s.parse::<String>().unwrap()),)]
         feature_type: Option<String>,
 
@@ -460,6 +460,7 @@ fn main() {
                             "esil" => FeatureType::Esil,
                             #[cfg(feature = "inference")]
                             "embed" => FeatureType::ModelEmbedded,
+                            "pcode" => FeatureType::Pcode,
                             _ => FeatureType::Invalid,
                         };
 
@@ -493,7 +494,7 @@ fn main() {
                                     WalkDir::new(path).into_iter().filter_map(|file| file.ok())
                                 {
                                     if file.path().to_string_lossy().ends_with(".json") {
-                                        validate_input(path, "cfg");
+                                        validate_input(file.path(), "cfg");
                                         agfj_graph_statistical_features(
                                             file.path(),
                                             &min_blocks.unwrap(),
@@ -524,6 +525,60 @@ fn main() {
                                     );
                                 }
                             }
+                        } else if feature_vec_type == FeatureType::Pcode {
+                            if Path::new(path).is_file() {
+                                validate_input(path, "cfg");
+                                info!("Single file found");
+                                let mut file = PCodeFile {
+                                    filename: path.to_owned(),
+                                    pcode_obj: None,
+                                    output_path: output_path.to_owned(),
+                                    min_blocks: *min_blocks,
+                                    instruction_pairs: false,
+                                    format_type: FormatMode::SingleInstruction,
+                                    pcode_file_type: PCodeFileTypes::PCodeJsonFile,
+                                };
+                                let file_ret = file.load_and_deserialize().is_ok();
+                                if file_ret {
+                                    let cfg_gen_ret =
+                                        file.pcode_json_with_bb_info_generate_cfg().is_ok();
+                                    if cfg_gen_ret {
+                                        info!("Successfully generated CFG's with PCode features")
+                                    } else {
+                                        error!("Failed to generate CFG's with PCode features")
+                                    }
+                                }
+                            } else {
+                                info!("[L551] Multiple files found. Will parallel process.");
+                                for file in
+                                    WalkDir::new(path).into_iter().filter_map(|file| file.ok())
+                                {
+                                    if file.path().to_string_lossy().ends_with(".json") {
+                                        validate_input(file.path(), "cfg");
+                                        let mut file = PCodeFile {
+                                            filename: file.path().to_owned(),
+                                            pcode_obj: None,
+                                            output_path: output_path.to_owned(),
+                                            min_blocks: *min_blocks,
+                                            instruction_pairs: false,
+                                            format_type: FormatMode::SingleInstruction,
+                                            pcode_file_type: PCodeFileTypes::PCodeJsonFile,
+                                        };
+                                        let file_ret = file.load_and_deserialize().is_ok();
+                                        if file_ret {
+                                            let cfg_gen_ret =
+                                                file.pcode_json_with_bb_info_generate_cfg().is_ok();
+                                            if cfg_gen_ret {
+                                                info!("Successfully generated CFG's with PCode features")
+                                            } else {
+                                                error!(
+                                                    "Failed to generate CFG's with PCode features"
+                                                )
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         }
                     } else {
                         error!("--feature-type/-f is required for creating CFG's")
diff --git a/src/networkx.rs b/src/networkx.rs
index d747ece..e4f8a33 100644
--- a/src/networkx.rs
+++ b/src/networkx.rs
@@ -2,10 +2,14 @@ use crate::afij::AFIJFeatureSubset;
 use crate::agfj::TikNibFunc;
 use crate::bb::{FeatureType, TikNibFeaturesBB};
 use crate::combos::FinfoTiknib;
+use crate::extract::PCodeJsonWithBBAndFuncName;
 use enum_as_inner::EnumAsInner;
 use petgraph::prelude::Graph;
 use petgraph::visit::EdgeRef;
 use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -17,6 +21,19 @@ pub struct NetworkxDiGraph<N> {
     pub nodes: Vec<N>,
 }
 
+impl<N: Serialize> NetworkxDiGraph<N> {
+    pub fn save_to_json<P: AsRef<Path>>(&self, path: P) -> std::io::Result<()> {
+        // Serialize the struct to a JSON string
+        let json = serde_json::to_string(self)?;
+
+        // Open the file and write the JSON string
+        let mut file = File::create(path)?;
+        file.write_all(json.as_bytes())?;
+
+        Ok(())
+    }
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Adjacency {
@@ -32,6 +49,7 @@ pub enum NodeType {
     Tiknib(TiknibNode),
     Disasm(DisasmNode),
     Esil(EsilNode),
+    PCode(PCodeNode),
 }
 
 #[derive(Debug, Clone, PartialEq, Hash, Serialize, Deserialize, EnumAsInner)]
@@ -622,3 +640,75 @@ impl From<NetworkxDiGraph<NodeType>> for NetworkxDiGraph<EsilNode> {
         }
     }
 }
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct PCodeNode {
+    pub id: u64,
+    pub start_addr: u64,
+    pub features: Vec<String>,
+}
+
+impl From<(u64, u64, &Vec<String>)> for PCodeNode {
+    fn from(src: (u64, u64, &Vec<String>)) -> PCodeNode {
+        PCodeNode {
+            id: src.0,
+            start_addr: src.1,
+            features: src.2.to_owned(),
+        }
+    }
+}
+
+impl From<(&Graph<String, u32>, &PCodeJsonWithBBAndFuncName, &Vec<u32>)>
+    for NetworkxDiGraph<PCodeNode>
+{
+    fn from(
+        input: (&Graph<String, u32>, &PCodeJsonWithBBAndFuncName, &Vec<u32>),
+    ) -> NetworkxDiGraph<PCodeNode> {
+        let mut nodes: Vec<NodeType> = vec![];
+
+        for (idx, address) in input.2.iter().enumerate() {
+            let pcode_node = input
+                .1
+                .pcode_blocks
+                .iter()
+                .find(|ele| ele.block_start_adr as u32 == *address);
+            if let Some(pcode_node) = pcode_node {
+                nodes.push(NodeType::PCode(PCodeNode::from((
+                    idx as u64,
+                    pcode_node.block_start_adr,
+                    &pcode_node.pcode,
+                ))))
+            }
+        }
+
+        // Sort edges out
+        let mut adjacency: Vec<Vec<Adjacency>> = vec![];
+        let node_indices = input.0.node_indices();
+
+        for node in node_indices {
+            let mut node_adjacency_vec = vec![];
+            let node_edges = input.0.edges(node);
+            for edge in node_edges {
+                let edge_entry = Adjacency {
+                    id: edge.target().index(),
+                    weight: edge.weight().to_owned(),
+                };
+                node_adjacency_vec.push(edge_entry)
+            }
+            adjacency.push(node_adjacency_vec)
+        }
+
+        let inner_nodes_types: Vec<PCodeNode> = nodes
+            .into_iter()
+            .map(|el| el.as_p_code().unwrap().clone())
+            .collect();
+
+        NetworkxDiGraph {
+            adjacency,
+            directed: "True".to_string(),
+            graph: vec![],
+            multigraph: false,
+            nodes: inner_nodes_types,
+        }
+    }
+}
diff --git a/src/pcode.rs b/src/pcode.rs
index 2a9dc4b..7f52bf9 100644
--- a/src/pcode.rs
+++ b/src/pcode.rs
@@ -1,7 +1,10 @@
 use crate::extract::{PCodeJSONWithFuncName, PCodeJsonWithBB, PCodeJsonWithBBAndFuncName};
 use crate::files::FormatMode;
+use crate::networkx::NetworkxDiGraph;
 use crate::utils::get_save_file_path;
 use enum_as_inner::EnumAsInner;
+use indicatif::ParallelProgressIterator;
+use petgraph::Graph;
 use rayon::iter::IntoParallelRefIterator;
 use rayon::prelude::ParallelIterator;
 use serde::{Deserialize, Serialize};
@@ -339,4 +342,160 @@ impl PCodeFile {
                 .expect("Unable to write bytes.");
         }
     }
+
+    pub fn pcode_json_with_bb_info_generate_cfg(&mut self) -> Result<(), ()> {
+        let pcode_obj = self.pcode_obj.clone().unwrap();
+
+        pcode_obj.par_iter().progress().for_each(|function| {
+            let function_name = function
+                .as_p_code_json_with_bb()
+                .unwrap()
+                .function_name
+                .clone();
+            let pcode_json_with_bb = function.as_p_code_json_with_bb().unwrap();
+            let (graph, start_addrs) = pcode_json_with_bb.get_cfg();
+            let nx_graph = NetworkxDiGraph::from((&graph, pcode_json_with_bb, &start_addrs));
+            let mut file_out_path =
+                get_save_file_path(&self.filename, &self.output_path, None, None, None);
+            file_out_path.push(&format!("{}_pcode_cfg.json", &function_name));
+
+            if !file_out_path.parent().unwrap().exists() {
+                std::fs::create_dir_all(file_out_path.parent().unwrap()).unwrap();
+            }
+
+            let ret = nx_graph.save_to_json(&file_out_path);
+            if ret.is_ok() {
+                debug!("Successfully saved CFG for function: {}", &function_name);
+            } else {
+                error!(
+                    "Error saving CFG for function: {} - Error: {}",
+                    &function_name,
+                    ret.err().unwrap()
+                );
+            }
+        });
+        Ok(())
+    }
+}
+
+impl PCodeJsonWithBBAndFuncName {
+    pub fn get_cfg(&self) -> (Graph<String, u32>, Vec<u32>) {
+        let pcode_blocks: &Vec<PCodeJsonWithBB> = self.pcode_blocks.as_ref();
+        let mut edge_list: Vec<(u32, u32, u32)> = Vec::new();
+        let mut start_addrs: Vec<u32> = Vec::new();
+        if pcode_blocks.len() == 1 {
+            let mut graph: Graph<String, u32> = Graph::new();
+            graph.add_node(pcode_blocks[0].block_start_adr.to_string());
+            start_addrs.push(pcode_blocks[0].block_start_adr as u32);
+            return (graph, start_addrs);
+        }
+
+        for block in pcode_blocks {
+            if !start_addrs.contains(&(block.block_start_adr as u32)) {
+                start_addrs.push(block.block_start_adr as u32);
+            }
+
+            let block_start_idx = start_addrs
+                .iter()
+                .position(|&p| p == block.block_start_adr as u32);
+
+            if block.bb_info.fail.is_some() {
+                let fail = block.bb_info.fail.unwrap();
+                if !start_addrs.contains(&(fail as u32)) {
+                    start_addrs.push(fail as u32);
+                }
+                let fail_idx = start_addrs.iter().position(|&p| p == fail as u32);
+                edge_list.push((block_start_idx.unwrap() as u32, fail_idx.unwrap() as u32, 0));
+            }
+
+            if block.bb_info.jump.is_some() {
+                let jump = block.bb_info.jump.unwrap();
+                if !start_addrs.contains(&(jump as u32)) {
+                    start_addrs.push(jump as u32);
+                }
+                let jump_idx = start_addrs.iter().position(|&p| p == jump as u32);
+                edge_list.push((block_start_idx.unwrap() as u32, jump_idx.unwrap() as u32, 1));
+            }
+        }
+        (Graph::from_edges(&edge_list), start_addrs)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::files::FormatMode;
+    use crate::networkx::{NetworkxDiGraph, PCodeNode};
+    use crate::pcode::{PCodeFile, PCodeFileTypes};
+    use petgraph::graph::NodeIndex;
+    use petgraph::{Incoming, Outgoing};
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_pcode_graph_gen() {
+        let mut pcode_file = PCodeFile {
+            filename: PathBuf::from("test-files/test_bin_pcode-bb.json"),
+            pcode_obj: None,
+            output_path: Default::default(),
+            min_blocks: None,
+            instruction_pairs: false,
+            format_type: FormatMode::SingleInstruction,
+            pcode_file_type: PCodeFileTypes::PCodeWithBBFile,
+        };
+
+        pcode_file
+            .load_and_deserialize()
+            .expect("Unable to load and deserialize PCode file");
+
+        // Test the case where a CFG only has a single node
+        let pcode_binding = pcode_file.pcode_obj.unwrap();
+        let pcode_json_with_bb = pcode_binding[0].as_p_code_json_with_bb().unwrap();
+        let (graph, start_addrs) = pcode_json_with_bb.get_cfg();
+        assert_eq!(graph.node_count(), 1);
+        let nx_graph: NetworkxDiGraph<PCodeNode> =
+            NetworkxDiGraph::from((&graph, pcode_json_with_bb, &start_addrs));
+        assert_eq!(nx_graph.nodes.len(), 1);
+
+        // Test the case where the CFG has several nodes - Index 10 = main of test_bin
+        let pcode_json_with_bb = pcode_binding[10].as_p_code_json_with_bb().unwrap();
+        let (graph, start_addrs) = pcode_json_with_bb.get_cfg();
+
+        // Check generic features
+        assert_eq!(graph.node_count(), 9);
+        assert_eq!(graph.edge_count(), 11);
+        assert_eq!(graph.is_directed(), true);
+
+        // Check structure
+
+        // Outgoing Edges from Nodes
+        let expected_outgoing_edges = vec![2, 1, 1, 2, 1, 2, 0, 1, 1];
+        for (idx, _) in start_addrs.iter().enumerate() {
+            let outgoing_edges = graph
+                .edges_directed(NodeIndex::from(idx as u32), Outgoing)
+                .count();
+            assert_eq!(expected_outgoing_edges[idx], outgoing_edges);
+        }
+        // Incoming Edges to Nodes
+        let expected_incoming_edges = vec![0, 1, 1, 2, 1, 1, 3, 1, 1];
+        for (idx, _) in start_addrs.iter().enumerate() {
+            let outgoing_edges = graph
+                .edges_directed(NodeIndex::from(idx as u32), Incoming)
+                .count();
+            assert_eq!(expected_incoming_edges[idx], outgoing_edges);
+        }
+
+        // Check conversion + mapping of node data
+        let nx_graph: NetworkxDiGraph<PCodeNode> =
+            NetworkxDiGraph::from((&graph, pcode_json_with_bb, &start_addrs));
+        assert_eq!(nx_graph.nodes.len(), 9);
+
+        // Check node start addresses which are used to map features -> nodes
+        for (idx, addr) in start_addrs.iter().enumerate() {
+            assert_eq!(nx_graph.nodes[idx].start_addr as u32, *addr);
+        }
+
+        // Check saving
+        let save_ret = nx_graph.save_to_json("test_pcode_graph.json").is_ok();
+        assert_eq!(save_ret, true);
+        std::fs::remove_file("test_pcode_graph.json").unwrap()
+    }
 }
diff --git a/src/utils.rs b/src/utils.rs
index 3821b08..7f30dc1 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -105,7 +105,7 @@ pub fn check_or_create_dir(full_output_path: &PathBuf) {
     }
 }
 
-/// Average
+/// Calculates the average of a vector of f32's
 pub fn average(numbers: Vec<f32>) -> f32 {
     numbers.iter().sum::<f32>() / numbers.len() as f32
 }
diff --git a/src/validate.rs b/src/validate.rs
index 25ba0f4..6f2179f 100644
--- a/src/validate.rs
+++ b/src/validate.rs
@@ -8,7 +8,9 @@ pub fn validate_input(filepath: &Path, command: &str) {
 }
 
 fn check_file_is_json(filepath: &Path) {
+    debug!("Filepath: {}", filepath.display());
     let file_extension = filepath.extension();
+    debug!("File extension: {:?}", file_extension);
     if Some(OsStr::new("json")) == file_extension {
         debug!("Found the correct file format!")
     } else {
@@ -36,7 +38,7 @@ fn check_file_is_expected_type(filepath: &Path, command: &str) {
     };
 
     let valid = match command {
-        "cfg" => file_type_provided == "controlflow",
+        "cfg" => (file_type_provided == "controlflow") | (file_type_provided == "pcode"),
         "cg" => file_type_provided == "callgraph",
         "metadata_finfo" => file_type_provided == "function_info",
         "metadata_tiknib" => file_type_provided == "controlflow",
diff --git a/test-files/test_bin_pcode-bb.json b/test-files/test_bin_pcode-bb.json
new file mode 100644
index 0000000..5164132
--- /dev/null
+++ b/test-files/test_bin_pcode-bb.json
@@ -0,0 +1,5160 @@
+[
+  {
+    "function_name": "entry0",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001060: ENDBR64",
+          "0x00001064: XOR EBP,EBP",
+          "0x00001066: MOV R9,RDX",
+          "0x00001069: POP RSI",
+          "0x0000106a: MOV RDX,RSP",
+          "0x0000106d: AND RSP,-0x10",
+          "0x00001071: PUSH RAX",
+          "0x00001072: PUSH RSP",
+          "0x00001073: LEA R8,[0x1260]",
+          "0x0000107a: LEA RCX,[0x11f0]",
+          "0x00001081: LEA RDI,[0x1149]",
+          "0x00001088: CALL qword ptr [0x3fe0]",
+          "0x0000108e: HLT"
+        ],
+        "bb_info": {
+          "addr": 4192,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4192,
+            4196,
+            4198,
+            4201,
+            4202,
+            4205,
+            4209,
+            4210,
+            4211,
+            4218,
+            4225,
+            4232,
+            4238
+          ],
+          "jump": null,
+          "ninstr": 13,
+          "opaddr": 4192,
+          "outputs": 0,
+          "size": 47,
+          "traced": false
+        },
+        "block_start_adr": 4192,
+        "pcode": [
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "EBP = INT_XOR EBP, EBP",
+          "RBP = INT_ZEXT EBP",
+          "SF = INT_SLESS EBP, 0x0",
+          "ZF = INT_EQUAL EBP, 0x0",
+          "(unique,0x12e80,4) = INT_AND EBP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "R9 = COPY RDX",
+          "RSI = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RDX = COPY RSP",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "RSP = INT_AND RSP, 0xfffffffffffffff0",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xea00,8) = COPY RAX",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "(unique,0xea00,8) = COPY RSP",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "R8 = COPY 0x1260",
+          "RCX = COPY 0x11f0",
+          "RDI = COPY 0x1149",
+          "(unique,0x27700,8) = COPY qword_ptr(0x00003fe0)",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x108e = STORE ram[RSP]",
+          "CALLIND (unique,0x27700,8)",
+          "BRANCH qword_ptr(0x0000108e)"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.deregister_tm_clones",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001090: LEA RDI,[0x4010]",
+          "0x00001097: LEA RAX,[0x4010]",
+          "0x0000109e: CMP RAX,RDI",
+          "0x000010a1: JZ 0x10b8"
+        ],
+        "bb_info": {
+          "addr": 4240,
+          "fail": 4259,
+          "inputs": 0,
+          "instrs": [
+            4240,
+            4247,
+            4254,
+            4257
+          ],
+          "jump": 4280,
+          "ninstr": 4,
+          "opaddr": 4240,
+          "outputs": 2,
+          "size": 19,
+          "traced": false
+        },
+        "block_start_adr": 4240,
+        "pcode": [
+          "RDI = COPY 0x4010",
+          "RAX = COPY 0x4010",
+          "CF = INT_LESS RAX, RDI",
+          "OF = INT_SBORROW RAX, RDI",
+          "(unique,0x29500,8) = INT_SUB RAX, RDI",
+          "SF = INT_SLESS (unique,0x29500,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x29500,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x29500,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x000010b8), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010a3: MOV RAX,qword ptr [0x3fd8]",
+          "0x000010aa: TEST RAX,RAX",
+          "0x000010ad: JZ 0x10b8"
+        ],
+        "bb_info": {
+          "addr": 4259,
+          "fail": 4271,
+          "inputs": 1,
+          "instrs": [
+            4259,
+            4266,
+            4269
+          ],
+          "jump": 4280,
+          "ninstr": 3,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 12,
+          "traced": false
+        },
+        "block_start_adr": 4259,
+        "pcode": [
+          "RAX = COPY qword_ptr(0x00003fd8)",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "(unique,0x5b200,8) = INT_AND RAX, RAX",
+          "SF = INT_SLESS (unique,0x5b200,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x5b200,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x5b200,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x000010b8), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010af: JMP RAX"
+        ],
+        "bb_info": {
+          "addr": 4271,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4271
+          ],
+          "jump": null,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 2,
+          "traced": false
+        },
+        "block_start_adr": 4271,
+        "pcode": [
+          "BRANCHIND RAX"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010b8: RET"
+        ],
+        "bb_info": {
+          "addr": 4280,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            4280
+          ],
+          "jump": null,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 1,
+          "traced": false
+        },
+        "block_start_adr": 4280,
+        "pcode": [
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.register_tm_clones",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x000010c0: LEA RDI,[0x4010]",
+          "0x000010c7: LEA RSI,[0x4010]",
+          "0x000010ce: SUB RSI,RDI",
+          "0x000010d1: MOV RAX,RSI",
+          "0x000010d4: SHR RSI,0x3f",
+          "0x000010d8: SAR RAX,0x3",
+          "0x000010dc: ADD RSI,RAX",
+          "0x000010df: SAR RSI,1",
+          "0x000010e2: JZ 0x10f8"
+        ],
+        "bb_info": {
+          "addr": 4288,
+          "fail": 4324,
+          "inputs": 0,
+          "instrs": [
+            4288,
+            4295,
+            4302,
+            4305,
+            4308,
+            4312,
+            4316,
+            4319,
+            4322
+          ],
+          "jump": 4344,
+          "ninstr": 9,
+          "opaddr": 4288,
+          "outputs": 2,
+          "size": 36,
+          "traced": false
+        },
+        "block_start_adr": 4288,
+        "pcode": [
+          "RDI = COPY 0x4010",
+          "RSI = COPY 0x4010",
+          "CF = INT_LESS RSI, RDI",
+          "OF = INT_SBORROW RSI, RDI",
+          "RSI = INT_SUB RSI, RDI",
+          "SF = INT_SLESS RSI, 0x0",
+          "ZF = INT_EQUAL RSI, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSI, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RAX = COPY RSI",
+          "(unique,0x59780,4) = INT_AND 0x3f, 0x3f",
+          "(unique,0x59800,8) = COPY RSI",
+          "RSI = INT_RIGHT RSI, (unique,0x59780,4)",
+          "(unique,0x16380,1) = INT_NOTEQUAL (unique,0x59780,4), 0x0",
+          "(unique,0x16400,4) = INT_SUB (unique,0x59780,4), 0x1",
+          "(unique,0x16480,8) = INT_RIGHT (unique,0x59800,8), (unique,0x16400,4)",
+          "(unique,0x16500,8) = INT_AND (unique,0x16480,8), 0x1",
+          "(unique,0x16600,1) = INT_NOTEQUAL (unique,0x16500,8), 0x0",
+          "(unique,0x16680,1) = BOOL_NEGATE (unique,0x16380,1)",
+          "(unique,0x16700,1) = INT_AND (unique,0x16680,1), CF",
+          "(unique,0x16780,1) = INT_AND (unique,0x16380,1), (unique,0x16600,1)",
+          "CF = INT_OR (unique,0x16700,1), (unique,0x16780,1)",
+          "(unique,0x16900,1) = INT_EQUAL (unique,0x59780,4), 0x1",
+          "(unique,0x16a00,1) = INT_SLESS (unique,0x59800,8), 0x0",
+          "(unique,0x16a80,1) = BOOL_NEGATE (unique,0x16900,1)",
+          "(unique,0x16b00,1) = INT_AND (unique,0x16a80,1), OF",
+          "(unique,0x16b80,1) = INT_AND (unique,0x16900,1), (unique,0x16a00,1)",
+          "OF = INT_OR (unique,0x16b00,1), (unique,0x16b80,1)",
+          "(unique,0x13100,1) = INT_NOTEQUAL (unique,0x59780,4), 0x0",
+          "(unique,0x13200,1) = INT_SLESS RSI, 0x0",
+          "(unique,0x13280,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13300,1) = INT_AND (unique,0x13280,1), SF",
+          "(unique,0x13380,1) = INT_AND (unique,0x13100,1), (unique,0x13200,1)",
+          "SF = INT_OR (unique,0x13300,1), (unique,0x13380,1)",
+          "(unique,0x13500,1) = INT_EQUAL RSI, 0x0",
+          "(unique,0x13580,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13600,1) = INT_AND (unique,0x13580,1), ZF",
+          "(unique,0x13680,1) = INT_AND (unique,0x13100,1), (unique,0x13500,1)",
+          "ZF = INT_OR (unique,0x13600,1), (unique,0x13680,1)",
+          "(unique,0x13780,8) = INT_AND RSI, 0xff",
+          "(unique,0x13800,1) = POPCOUNT (unique,0x13780,8)",
+          "(unique,0x13880,1) = INT_AND (unique,0x13800,1), 0x1",
+          "(unique,0x13980,1) = INT_EQUAL (unique,0x13880,1), 0x0",
+          "(unique,0x13a00,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13a80,1) = INT_AND (unique,0x13a00,1), PF",
+          "(unique,0x13b00,1) = INT_AND (unique,0x13100,1), (unique,0x13980,1)",
+          "PF = INT_OR (unique,0x13a80,1), (unique,0x13b00,1)",
+          "(unique,0x53a80,4) = INT_AND 0x3, 0x3f",
+          "(unique,0x53b00,8) = COPY RAX",
+          "RAX = INT_SRIGHT RAX, (unique,0x53a80,4)",
+          "(unique,0x15c00,1) = INT_NOTEQUAL (unique,0x53a80,4), 0x0",
+          "(unique,0x15c80,4) = INT_SUB (unique,0x53a80,4), 0x1",
+          "(unique,0x15d00,8) = INT_SRIGHT (unique,0x53b00,8), (unique,0x15c80,4)",
+          "(unique,0x15d80,8) = INT_AND (unique,0x15d00,8), 0x1",
+          "(unique,0x15e80,1) = INT_NOTEQUAL (unique,0x15d80,8), 0x0",
+          "(unique,0x15f00,1) = BOOL_NEGATE (unique,0x15c00,1)",
+          "(unique,0x15f80,1) = INT_AND (unique,0x15f00,1), CF",
+          "(unique,0x16000,1) = INT_AND (unique,0x15c00,1), (unique,0x15e80,1)",
+          "CF = INT_OR (unique,0x15f80,1), (unique,0x16000,1)",
+          "(unique,0x16180,1) = INT_EQUAL (unique,0x53a80,4), 0x1",
+          "(unique,0x16200,1) = BOOL_NEGATE (unique,0x16180,1)",
+          "OF = INT_AND (unique,0x16200,1), OF",
+          "(unique,0x13100,1) = INT_NOTEQUAL (unique,0x53a80,4), 0x0",
+          "(unique,0x13200,1) = INT_SLESS RAX, 0x0",
+          "(unique,0x13280,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13300,1) = INT_AND (unique,0x13280,1), SF",
+          "(unique,0x13380,1) = INT_AND (unique,0x13100,1), (unique,0x13200,1)",
+          "SF = INT_OR (unique,0x13300,1), (unique,0x13380,1)",
+          "(unique,0x13500,1) = INT_EQUAL RAX, 0x0",
+          "(unique,0x13580,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13600,1) = INT_AND (unique,0x13580,1), ZF",
+          "(unique,0x13680,1) = INT_AND (unique,0x13100,1), (unique,0x13500,1)",
+          "ZF = INT_OR (unique,0x13600,1), (unique,0x13680,1)",
+          "(unique,0x13780,8) = INT_AND RAX, 0xff",
+          "(unique,0x13800,1) = POPCOUNT (unique,0x13780,8)",
+          "(unique,0x13880,1) = INT_AND (unique,0x13800,1), 0x1",
+          "(unique,0x13980,1) = INT_EQUAL (unique,0x13880,1), 0x0",
+          "(unique,0x13a00,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13a80,1) = INT_AND (unique,0x13a00,1), PF",
+          "(unique,0x13b00,1) = INT_AND (unique,0x13100,1), (unique,0x13980,1)",
+          "PF = INT_OR (unique,0x13a80,1), (unique,0x13b00,1)",
+          "CF = INT_CARRY RSI, RAX",
+          "OF = INT_SCARRY RSI, RAX",
+          "RSI = INT_ADD RSI, RAX",
+          "SF = INT_SLESS RSI, 0x0",
+          "ZF = INT_EQUAL RSI, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSI, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xc100,1) = COPY 0x1",
+          "(unique,0x53680,8) = INT_AND RSI, 0x1",
+          "CF = INT_NOTEQUAL (unique,0x53680,8), 0x0",
+          "OF = COPY 0x0",
+          "RSI = INT_SRIGHT RSI, 0x1",
+          "SF = INT_SLESS RSI, 0x0",
+          "ZF = INT_EQUAL RSI, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSI, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x000010f8), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010e4: MOV RAX,qword ptr [0x3ff0]",
+          "0x000010eb: TEST RAX,RAX",
+          "0x000010ee: JZ 0x10f8"
+        ],
+        "bb_info": {
+          "addr": 4324,
+          "fail": 4336,
+          "inputs": 1,
+          "instrs": [
+            4324,
+            4331,
+            4334
+          ],
+          "jump": 4344,
+          "ninstr": 3,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 12,
+          "traced": false
+        },
+        "block_start_adr": 4324,
+        "pcode": [
+          "RAX = COPY qword_ptr(0x00003ff0)",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "(unique,0x5b200,8) = INT_AND RAX, RAX",
+          "SF = INT_SLESS (unique,0x5b200,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x5b200,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x5b200,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x000010f8), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010f0: JMP RAX"
+        ],
+        "bb_info": {
+          "addr": 4336,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4336
+          ],
+          "jump": null,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 2,
+          "traced": false
+        },
+        "block_start_adr": 4336,
+        "pcode": [
+          "BRANCHIND RAX"
+        ]
+      },
+      {
+        "asm": [
+          "0x000010f8: RET"
+        ],
+        "bb_info": {
+          "addr": 4344,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            4344
+          ],
+          "jump": null,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 1,
+          "traced": false
+        },
+        "block_start_adr": 4344,
+        "pcode": [
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.__do_global_dtors_aux",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001100: ENDBR64",
+          "0x00001104: CMP byte ptr [0x4010],0x0",
+          "0x0000110b: JNZ 0x1138"
+        ],
+        "bb_info": {
+          "addr": 4352,
+          "fail": 4365,
+          "inputs": 0,
+          "instrs": [
+            4352,
+            4356,
+            4363
+          ],
+          "jump": 4408,
+          "ninstr": 3,
+          "opaddr": 4352,
+          "outputs": 2,
+          "size": 13,
+          "traced": false
+        },
+        "block_start_adr": 4352,
+        "pcode": [
+          "CF = INT_LESS byte_ptr(0x00004010), 0x0",
+          "OF = INT_SBORROW byte_ptr(0x00004010), 0x0",
+          "(unique,0x28b00,1) = INT_SUB byte_ptr(0x00004010), 0x0",
+          "SF = INT_SLESS (unique,0x28b00,1), 0x0",
+          "ZF = INT_EQUAL (unique,0x28b00,1), 0x0",
+          "(unique,0x12e80,1) = INT_AND (unique,0x28b00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xc900,1) = BOOL_NEGATE ZF",
+          "CBRANCH qword_ptr(0x00001138), (unique,0xc900,1)"
+        ]
+      },
+      {
+        "asm": [
+          "0x0000110d: PUSH RBP",
+          "0x0000110e: CMP qword ptr [0x3ff8],0x0",
+          "0x00001116: MOV RBP,RSP",
+          "0x00001119: JZ 0x1127"
+        ],
+        "bb_info": {
+          "addr": 4365,
+          "fail": 4379,
+          "inputs": 1,
+          "instrs": [
+            4365,
+            4366,
+            4374,
+            4377
+          ],
+          "jump": 4391,
+          "ninstr": 4,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 14,
+          "traced": false
+        },
+        "block_start_adr": 4365,
+        "pcode": [
+          "(unique,0xea00,8) = COPY RBP",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "CF = INT_LESS qword_ptr(0x00003ff8), 0x0",
+          "OF = INT_SBORROW qword_ptr(0x00003ff8), 0x0",
+          "(unique,0x29100,8) = INT_SUB qword_ptr(0x00003ff8), 0x0",
+          "SF = INT_SLESS (unique,0x29100,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x29100,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x29100,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RBP = COPY RSP",
+          "CBRANCH qword_ptr(0x00001127), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x0000111b: MOV RDI,qword ptr [0x4008]",
+          "0x00001122: CALL 0x1040"
+        ],
+        "bb_info": {
+          "addr": 4379,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4379,
+            4386
+          ],
+          "jump": 4391,
+          "ninstr": 2,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 12,
+          "traced": false
+        },
+        "block_start_adr": 4379,
+        "pcode": [
+          "RDI = COPY qword_ptr(0x00004008)",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1127 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001040)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001127: CALL 0x1090",
+          "0x0000112c: MOV byte ptr [0x4010],0x1",
+          "0x00001133: POP RBP",
+          "0x00001134: RET"
+        ],
+        "bb_info": {
+          "addr": 4391,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            4391,
+            4396,
+            4403,
+            4404
+          ],
+          "jump": null,
+          "ninstr": 4,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 14,
+          "traced": false
+        },
+        "block_start_adr": 4391,
+        "pcode": [
+          "RSP = INT_SUB RSP, 0x8",
+          "0x112c = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001090)",
+          "byte_ptr(0x00004010) = COPY 0x1",
+          "RBP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001138: RET"
+        ],
+        "bb_info": {
+          "addr": 4408,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4408
+          ],
+          "jump": null,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 1,
+          "traced": false
+        },
+        "block_start_adr": 4408,
+        "pcode": [
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym..plt.got",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001040: ENDBR64",
+          "0x00001044: JMP qword ptr [0x3ff8]"
+        ],
+        "bb_info": {
+          "addr": 4160,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4160,
+            4164
+          ],
+          "jump": null,
+          "ninstr": 2,
+          "opaddr": 4160,
+          "outputs": 0,
+          "size": 11,
+          "traced": false
+        },
+        "block_start_adr": 4160,
+        "pcode": [
+          "BRANCHIND qword_ptr(0x00003ff8)"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "entry.init0",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001140: ENDBR64",
+          "0x00001144: JMP 0x10c0"
+        ],
+        "bb_info": {
+          "addr": 4416,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4416,
+            4420
+          ],
+          "jump": 4288,
+          "ninstr": 2,
+          "opaddr": 4416,
+          "outputs": 1,
+          "size": 9,
+          "traced": false
+        },
+        "block_start_adr": 4416,
+        "pcode": [
+          "BRANCH qword_ptr(0x000010c0)"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym._init",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001000: ENDBR64",
+          "0x00001004: SUB RSP,0x8",
+          "0x00001008: MOV RAX,qword ptr [0x3fe8]",
+          "0x0000100f: TEST RAX,RAX",
+          "0x00001012: JZ 0x1016"
+        ],
+        "bb_info": {
+          "addr": 4096,
+          "fail": 4116,
+          "inputs": 0,
+          "instrs": [
+            4096,
+            4100,
+            4104,
+            4111,
+            4114
+          ],
+          "jump": 4118,
+          "ninstr": 5,
+          "opaddr": 4096,
+          "outputs": 2,
+          "size": 20,
+          "traced": false
+        },
+        "block_start_adr": 4096,
+        "pcode": [
+          "CF = INT_LESS RSP, 0x8",
+          "OF = INT_SBORROW RSP, 0x8",
+          "RSP = INT_SUB RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RAX = COPY qword_ptr(0x00003fe8)",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "(unique,0x5b200,8) = INT_AND RAX, RAX",
+          "SF = INT_SLESS (unique,0x5b200,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x5b200,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x5b200,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x00001016), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001014: CALL RAX"
+        ],
+        "bb_info": {
+          "addr": 4116,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4116
+          ],
+          "jump": 4118,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 2,
+          "traced": false
+        },
+        "block_start_adr": 4116,
+        "pcode": [
+          "(unique,0x27700,8) = COPY RAX",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1016 = STORE ram[RSP]",
+          "CALLIND (unique,0x27700,8)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001016: ADD RSP,0x8",
+          "0x0000101a: RET"
+        ],
+        "bb_info": {
+          "addr": 4118,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            4118,
+            4122
+          ],
+          "jump": null,
+          "ninstr": 2,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 5,
+          "traced": false
+        },
+        "block_start_adr": 4118,
+        "pcode": [
+          "CF = INT_CARRY RSP, 0x8",
+          "OF = INT_SCARRY RSP, 0x8",
+          "RSP = INT_ADD RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.__libc_csu_fini",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001260: ENDBR64",
+          "0x00001264: RET"
+        ],
+        "bb_info": {
+          "addr": 4704,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4704,
+            4708
+          ],
+          "jump": null,
+          "ninstr": 2,
+          "opaddr": 4704,
+          "outputs": 0,
+          "size": 5,
+          "traced": false
+        },
+        "block_start_adr": 4704,
+        "pcode": [
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym._fini",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001268: ENDBR64",
+          "0x0000126c: SUB RSP,0x8",
+          "0x00001270: ADD RSP,0x8",
+          "0x00001274: RET"
+        ],
+        "bb_info": {
+          "addr": 4712,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4712,
+            4716,
+            4720,
+            4724
+          ],
+          "jump": null,
+          "ninstr": 4,
+          "opaddr": 4712,
+          "outputs": 0,
+          "size": 13,
+          "traced": false
+        },
+        "block_start_adr": 4712,
+        "pcode": [
+          "CF = INT_LESS RSP, 0x8",
+          "OF = INT_SBORROW RSP, 0x8",
+          "RSP = INT_SUB RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY RSP, 0x8",
+          "OF = INT_SCARRY RSP, 0x8",
+          "RSP = INT_ADD RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.__libc_csu_init",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x000011f0: ENDBR64",
+          "0x000011f4: PUSH R15",
+          "0x000011f6: LEA R15,[0x3db8]",
+          "0x000011fd: PUSH R14",
+          "0x000011ff: MOV R14,RDX",
+          "0x00001202: PUSH R13",
+          "0x00001204: MOV R13,RSI",
+          "0x00001207: PUSH R12",
+          "0x00001209: MOV R12D,EDI",
+          "0x0000120c: PUSH RBP",
+          "0x0000120d: LEA RBP,[0x3dc0]",
+          "0x00001214: PUSH RBX",
+          "0x00001215: SUB RBP,R15",
+          "0x00001218: SUB RSP,0x8",
+          "0x0000121c: CALL 0x1000",
+          "0x00001221: SAR RBP,0x3",
+          "0x00001225: JZ 0x1246"
+        ],
+        "bb_info": {
+          "addr": 4592,
+          "fail": 4647,
+          "inputs": 0,
+          "instrs": [
+            4592,
+            4596,
+            4598,
+            4605,
+            4607,
+            4610,
+            4612,
+            4615,
+            4617,
+            4620,
+            4621,
+            4628,
+            4629,
+            4632,
+            4636,
+            4641,
+            4645
+          ],
+          "jump": 4678,
+          "ninstr": 17,
+          "opaddr": 4592,
+          "outputs": 2,
+          "size": 55,
+          "traced": false
+        },
+        "block_start_adr": 4592,
+        "pcode": [
+          "(unique,0xea00,8) = COPY R15",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "R15 = COPY 0x3db8",
+          "(unique,0xea00,8) = COPY R14",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "R14 = COPY RDX",
+          "(unique,0xea00,8) = COPY R13",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "R13 = COPY RSI",
+          "(unique,0xea00,8) = COPY R12",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "R12D = COPY EDI",
+          "R12 = INT_ZEXT R12D",
+          "(unique,0xea00,8) = COPY RBP",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "RBP = COPY 0x3dc0",
+          "(unique,0xea00,8) = COPY RBX",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "CF = INT_LESS RBP, R15",
+          "OF = INT_SBORROW RBP, R15",
+          "RBP = INT_SUB RBP, R15",
+          "SF = INT_SLESS RBP, 0x0",
+          "ZF = INT_EQUAL RBP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RBP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_LESS RSP, 0x8",
+          "OF = INT_SBORROW RSP, 0x8",
+          "RSP = INT_SUB RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1221 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001000)",
+          "(unique,0x53a80,4) = INT_AND 0x3, 0x3f",
+          "(unique,0x53b00,8) = COPY RBP",
+          "RBP = INT_SRIGHT RBP, (unique,0x53a80,4)",
+          "(unique,0x15c00,1) = INT_NOTEQUAL (unique,0x53a80,4), 0x0",
+          "(unique,0x15c80,4) = INT_SUB (unique,0x53a80,4), 0x1",
+          "(unique,0x15d00,8) = INT_SRIGHT (unique,0x53b00,8), (unique,0x15c80,4)",
+          "(unique,0x15d80,8) = INT_AND (unique,0x15d00,8), 0x1",
+          "(unique,0x15e80,1) = INT_NOTEQUAL (unique,0x15d80,8), 0x0",
+          "(unique,0x15f00,1) = BOOL_NEGATE (unique,0x15c00,1)",
+          "(unique,0x15f80,1) = INT_AND (unique,0x15f00,1), CF",
+          "(unique,0x16000,1) = INT_AND (unique,0x15c00,1), (unique,0x15e80,1)",
+          "CF = INT_OR (unique,0x15f80,1), (unique,0x16000,1)",
+          "(unique,0x16180,1) = INT_EQUAL (unique,0x53a80,4), 0x1",
+          "(unique,0x16200,1) = BOOL_NEGATE (unique,0x16180,1)",
+          "OF = INT_AND (unique,0x16200,1), OF",
+          "(unique,0x13100,1) = INT_NOTEQUAL (unique,0x53a80,4), 0x0",
+          "(unique,0x13200,1) = INT_SLESS RBP, 0x0",
+          "(unique,0x13280,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13300,1) = INT_AND (unique,0x13280,1), SF",
+          "(unique,0x13380,1) = INT_AND (unique,0x13100,1), (unique,0x13200,1)",
+          "SF = INT_OR (unique,0x13300,1), (unique,0x13380,1)",
+          "(unique,0x13500,1) = INT_EQUAL RBP, 0x0",
+          "(unique,0x13580,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13600,1) = INT_AND (unique,0x13580,1), ZF",
+          "(unique,0x13680,1) = INT_AND (unique,0x13100,1), (unique,0x13500,1)",
+          "ZF = INT_OR (unique,0x13600,1), (unique,0x13680,1)",
+          "(unique,0x13780,8) = INT_AND RBP, 0xff",
+          "(unique,0x13800,1) = POPCOUNT (unique,0x13780,8)",
+          "(unique,0x13880,1) = INT_AND (unique,0x13800,1), 0x1",
+          "(unique,0x13980,1) = INT_EQUAL (unique,0x13880,1), 0x0",
+          "(unique,0x13a00,1) = BOOL_NEGATE (unique,0x13100,1)",
+          "(unique,0x13a80,1) = INT_AND (unique,0x13a00,1), PF",
+          "(unique,0x13b00,1) = INT_AND (unique,0x13100,1), (unique,0x13980,1)",
+          "PF = INT_OR (unique,0x13a80,1), (unique,0x13b00,1)",
+          "CBRANCH qword_ptr(0x00001246), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001227: XOR EBX,EBX",
+          "0x00001229: NOP dword ptr [RAX]"
+        ],
+        "bb_info": {
+          "addr": 4647,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4647,
+            4649
+          ],
+          "jump": 4656,
+          "ninstr": 2,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 9,
+          "traced": false
+        },
+        "block_start_adr": 4647,
+        "pcode": [
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "EBX = INT_XOR EBX, EBX",
+          "RBX = INT_ZEXT EBX",
+          "SF = INT_SLESS EBX, 0x0",
+          "ZF = INT_EQUAL EBX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EBX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001230: MOV RDX,R14",
+          "0x00001233: MOV RSI,R13",
+          "0x00001236: MOV EDI,R12D",
+          "0x00001239: CALL qword ptr [R15 + RBX*0x8]",
+          "0x0000123d: ADD RBX,0x1",
+          "0x00001241: CMP RBP,RBX",
+          "0x00001244: JNZ 0x1230"
+        ],
+        "bb_info": {
+          "addr": 4656,
+          "fail": 4678,
+          "inputs": 2,
+          "instrs": [
+            4656,
+            4659,
+            4662,
+            4665,
+            4669,
+            4673,
+            4676
+          ],
+          "jump": 4656,
+          "ninstr": 7,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 22,
+          "traced": false
+        },
+        "block_start_adr": 4656,
+        "pcode": [
+          "RDX = COPY R14",
+          "RSI = COPY R13",
+          "EDI = COPY R12D",
+          "RDI = INT_ZEXT EDI",
+          "(unique,0x3300,8) = INT_MULT RBX, 0x8",
+          "(unique,0x3400,8) = INT_ADD R15, (unique,0x3300,8)",
+          "(unique,0xc000,8) = LOAD ram[(unique,0x3400,8)]",
+          "(unique,0x27700,8) = COPY (unique,0xc000,8)",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x123d = STORE ram[RSP]",
+          "CALLIND (unique,0x27700,8)",
+          "CF = INT_CARRY RBX, 0x1",
+          "OF = INT_SCARRY RBX, 0x1",
+          "RBX = INT_ADD RBX, 0x1",
+          "SF = INT_SLESS RBX, 0x0",
+          "ZF = INT_EQUAL RBX, 0x0",
+          "(unique,0x12e80,8) = INT_AND RBX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_LESS RBP, RBX",
+          "OF = INT_SBORROW RBP, RBX",
+          "(unique,0x29500,8) = INT_SUB RBP, RBX",
+          "SF = INT_SLESS (unique,0x29500,8), 0x0",
+          "ZF = INT_EQUAL (unique,0x29500,8), 0x0",
+          "(unique,0x12e80,8) = INT_AND (unique,0x29500,8), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xc900,1) = BOOL_NEGATE ZF",
+          "CBRANCH qword_ptr(0x00001230), (unique,0xc900,1)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001246: ADD RSP,0x8",
+          "0x0000124a: POP RBX",
+          "0x0000124b: POP RBP",
+          "0x0000124c: POP R12",
+          "0x0000124e: POP R13",
+          "0x00001250: POP R14",
+          "0x00001252: POP R15",
+          "0x00001254: RET"
+        ],
+        "bb_info": {
+          "addr": 4678,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            4678,
+            4682,
+            4683,
+            4684,
+            4686,
+            4688,
+            4690,
+            4692
+          ],
+          "jump": null,
+          "ninstr": 8,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 15,
+          "traced": false
+        },
+        "block_start_adr": 4678,
+        "pcode": [
+          "CF = INT_CARRY RSP, 0x8",
+          "OF = INT_SCARRY RSP, 0x8",
+          "RSP = INT_ADD RSP, 0x8",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RBX = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RBP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "R12 = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "R13 = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "R14 = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "R15 = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "main",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001149: ENDBR64",
+          "0x0000114d: PUSH RBP",
+          "0x0000114e: MOV RBP,RSP",
+          "0x00001151: SUB RSP,0x10",
+          "0x00001155: LEA RDI,[0x2004]",
+          "0x0000115c: MOV EAX,0x0",
+          "0x00001161: CALL 0x1050",
+          "0x00001166: MOV dword ptr [RBP + -0x8],0x0",
+          "0x0000116d: CMP dword ptr [RBP + -0x8],0x1",
+          "0x00001171: JZ 0x1186"
+        ],
+        "bb_info": {
+          "addr": 4425,
+          "fail": 4467,
+          "inputs": 0,
+          "instrs": [
+            4425,
+            4429,
+            4430,
+            4433,
+            4437,
+            4444,
+            4449,
+            4454,
+            4461,
+            4465
+          ],
+          "jump": 4486,
+          "ninstr": 10,
+          "opaddr": 4425,
+          "outputs": 2,
+          "size": 42,
+          "traced": false
+        },
+        "block_start_adr": 4425,
+        "pcode": [
+          "(unique,0xea00,8) = COPY RBP",
+          "RSP = INT_SUB RSP, 0x8",
+          "(unique,0xea00,8) = STORE ram[RSP]",
+          "RBP = COPY RSP",
+          "CF = INT_LESS RSP, 0x10",
+          "OF = INT_SBORROW RSP, 0x10",
+          "RSP = INT_SUB RSP, 0x10",
+          "SF = INT_SLESS RSP, 0x0",
+          "ZF = INT_EQUAL RSP, 0x0",
+          "(unique,0x12e80,8) = INT_AND RSP, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,8)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RDI = COPY 0x2004",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1166 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)",
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffff8",
+          "(unique,0xbf80,4) = COPY 0x0",
+          "(unique,0xbf80,4) = STORE ram[(unique,0x3100,8)]",
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffff8",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_LESS (unique,0xbf80,4), 0x1",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SBORROW (unique,0xbf80,4), 0x1",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x29000,4) = INT_SUB (unique,0xbf80,4), 0x1",
+          "SF = INT_SLESS (unique,0x29000,4), 0x0",
+          "ZF = INT_EQUAL (unique,0x29000,4), 0x0",
+          "(unique,0x12e80,4) = INT_AND (unique,0x29000,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x00001186), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001173: LEA RDI,[0x2022]",
+          "0x0000117a: MOV EAX,0x0",
+          "0x0000117f: CALL 0x1050",
+          "0x00001184: JMP 0x1197"
+        ],
+        "bb_info": {
+          "addr": 4467,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4467,
+            4474,
+            4479,
+            4484
+          ],
+          "jump": 4503,
+          "ninstr": 4,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 19,
+          "traced": false
+        },
+        "block_start_adr": 4467,
+        "pcode": [
+          "RDI = COPY 0x2022",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1184 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)",
+          "BRANCH qword_ptr(0x00001197)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001186: LEA RDI,[0x202b]",
+          "0x0000118d: MOV EAX,0x0",
+          "0x00001192: CALL 0x1050"
+        ],
+        "bb_info": {
+          "addr": 4486,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4486,
+            4493,
+            4498
+          ],
+          "jump": 4503,
+          "ninstr": 3,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 17,
+          "traced": false
+        },
+        "block_start_adr": 4486,
+        "pcode": [
+          "RDI = COPY 0x202b",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x1197 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00001197: MOV EAX,dword ptr [RBP + -0x8]",
+          "0x0000119a: ADD EAX,0x1",
+          "0x0000119d: MOV dword ptr [RBP + -0x4],EAX",
+          "0x000011a0: CMP dword ptr [RBP + -0x4],0x0",
+          "0x000011a4: JZ 0x11b9"
+        ],
+        "bb_info": {
+          "addr": 4503,
+          "fail": 4518,
+          "inputs": 2,
+          "instrs": [
+            4503,
+            4506,
+            4509,
+            4512,
+            4516
+          ],
+          "jump": 4537,
+          "ninstr": 5,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 15,
+          "traced": false
+        },
+        "block_start_adr": 4503,
+        "pcode": [
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffff8",
+          "(unique,0xbf00,4) = LOAD ram[(unique,0x3100,8)]",
+          "EAX = COPY (unique,0xbf00,4)",
+          "RAX = INT_ZEXT EAX",
+          "CF = INT_CARRY EAX, 0x1",
+          "OF = INT_SCARRY EAX, 0x1",
+          "EAX = INT_ADD EAX, 0x1",
+          "RAX = INT_ZEXT EAX",
+          "SF = INT_SLESS EAX, 0x0",
+          "ZF = INT_EQUAL EAX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EAX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffffc",
+          "(unique,0xbf00,4) = COPY EAX",
+          "(unique,0xbf00,4) = STORE ram[(unique,0x3100,8)]",
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffffc",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_LESS (unique,0xbf80,4), 0x0",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SBORROW (unique,0xbf80,4), 0x0",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x29000,4) = INT_SUB (unique,0xbf80,4), 0x0",
+          "SF = INT_SLESS (unique,0x29000,4), 0x0",
+          "ZF = INT_EQUAL (unique,0x29000,4), 0x0",
+          "(unique,0x12e80,4) = INT_AND (unique,0x29000,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CBRANCH qword_ptr(0x000011b9), ZF"
+        ]
+      },
+      {
+        "asm": [
+          "0x000011a6: LEA RDI,[0x2039]",
+          "0x000011ad: MOV EAX,0x0",
+          "0x000011b2: CALL 0x1050",
+          "0x000011b7: JMP 0x11e3"
+        ],
+        "bb_info": {
+          "addr": 4518,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4518,
+            4525,
+            4530,
+            4535
+          ],
+          "jump": 4579,
+          "ninstr": 4,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 19,
+          "traced": false
+        },
+        "block_start_adr": 4518,
+        "pcode": [
+          "RDI = COPY 0x2039",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x11b7 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)",
+          "BRANCH qword_ptr(0x000011e3)"
+        ]
+      },
+      {
+        "asm": [
+          "0x000011b9: CMP dword ptr [RBP + -0x4],0xa",
+          "0x000011bd: JNZ 0x11d2"
+        ],
+        "bb_info": {
+          "addr": 4537,
+          "fail": 4543,
+          "inputs": 1,
+          "instrs": [
+            4537,
+            4541
+          ],
+          "jump": 4562,
+          "ninstr": 2,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 6,
+          "traced": false
+        },
+        "block_start_adr": 4537,
+        "pcode": [
+          "(unique,0x3100,8) = INT_ADD RBP, 0xfffffffffffffffc",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_LESS (unique,0xbf80,4), 0xa",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SBORROW (unique,0xbf80,4), 0xa",
+          "(unique,0xbf80,4) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x29000,4) = INT_SUB (unique,0xbf80,4), 0xa",
+          "SF = INT_SLESS (unique,0x29000,4), 0x0",
+          "ZF = INT_EQUAL (unique,0x29000,4), 0x0",
+          "(unique,0x12e80,4) = INT_AND (unique,0x29000,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xc900,1) = BOOL_NEGATE ZF",
+          "CBRANCH qword_ptr(0x000011d2), (unique,0xc900,1)"
+        ]
+      },
+      {
+        "asm": [
+          "0x000011bf: LEA RDI,[0x2043]",
+          "0x000011c6: MOV EAX,0x0",
+          "0x000011cb: CALL 0x1050",
+          "0x000011d0: JMP 0x11e3"
+        ],
+        "bb_info": {
+          "addr": 4543,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4543,
+            4550,
+            4555,
+            4560
+          ],
+          "jump": 4579,
+          "ninstr": 4,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 19,
+          "traced": false
+        },
+        "block_start_adr": 4543,
+        "pcode": [
+          "RDI = COPY 0x2043",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x11d0 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)",
+          "BRANCH qword_ptr(0x000011e3)"
+        ]
+      },
+      {
+        "asm": [
+          "0x000011d2: LEA RDI,[0x2055]",
+          "0x000011d9: MOV EAX,0x0",
+          "0x000011de: CALL 0x1050"
+        ],
+        "bb_info": {
+          "addr": 4562,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            4562,
+            4569,
+            4574
+          ],
+          "jump": 4579,
+          "ninstr": 3,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 17,
+          "traced": false
+        },
+        "block_start_adr": 4562,
+        "pcode": [
+          "RDI = COPY 0x2055",
+          "RAX = COPY 0x0",
+          "RSP = INT_SUB RSP, 0x8",
+          "0x11e3 = STORE ram[RSP]",
+          "CALL qword_ptr(0x00001050)"
+        ]
+      },
+      {
+        "asm": [
+          "0x000011e3: MOV EAX,0x0",
+          "0x000011e8: LEAVE",
+          "0x000011e9: RET"
+        ],
+        "bb_info": {
+          "addr": 4579,
+          "fail": null,
+          "inputs": 3,
+          "instrs": [
+            4579,
+            4584,
+            4585
+          ],
+          "jump": null,
+          "ninstr": 3,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 7,
+          "traced": false
+        },
+        "block_start_adr": 4579,
+        "pcode": [
+          "RAX = COPY 0x0",
+          "RSP = COPY RBP",
+          "RBP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RIP = LOAD ram[RSP]",
+          "RSP = INT_ADD RSP, 0x8",
+          "RETURN RIP"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "sym.imp.printf",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00001050: ENDBR64",
+          "0x00001054: JMP qword ptr [0x3fd0]"
+        ],
+        "bb_info": {
+          "addr": 4176,
+          "fail": null,
+          "inputs": 0,
+          "instrs": [
+            4176,
+            4180
+          ],
+          "jump": null,
+          "ninstr": 2,
+          "opaddr": 4176,
+          "outputs": 0,
+          "size": 11,
+          "traced": false
+        },
+        "block_start_adr": 4176,
+        "pcode": [
+          "BRANCHIND qword_ptr(0x00003fd0)"
+        ]
+      }
+    ]
+  },
+  {
+    "function_name": "loc.imp._ITM_deregisterTMCloneTable",
+    "pcode_blocks": [
+      {
+        "asm": [
+          "0x00000000: JG 0x47"
+        ],
+        "bb_info": {
+          "addr": 0,
+          "fail": 2,
+          "inputs": 0,
+          "instrs": [
+            0
+          ],
+          "jump": 71,
+          "ninstr": 1,
+          "opaddr": 0,
+          "outputs": 2,
+          "size": 2,
+          "traced": false
+        },
+        "block_start_adr": 0,
+        "pcode": [
+          "(unique,0xd180,1) = BOOL_NEGATE ZF",
+          "(unique,0xd200,1) = INT_EQUAL OF, SF",
+          "(unique,0xd300,1) = BOOL_AND (unique,0xd180,1), (unique,0xd200,1)",
+          "CBRANCH qword_ptr(0x00000047), (unique,0xd300,1)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00000003: ADD R8B,byte ptr [RCX]",
+          "0x00000006: ADD dword ptr [RAX],EAX",
+          "0x00000008: ADD byte ptr [RAX],AL",
+          "0x0000000a: ADD byte ptr [RAX],AL",
+          "0x0000000c: ADD byte ptr [RAX],AL",
+          "0x0000000e: ADD byte ptr [RAX],AL",
+          "0x00000010: ADD EAX,dword ptr [RAX]",
+          "0x00000012: ADD byte ptr DS:[RCX],AL",
+          "0x00000015: ADD byte ptr [RAX],AL",
+          "0x00000017: ADD byte ptr [RAX + 0x10],AH",
+          "0x0000001a: ADD byte ptr [RAX],AL",
+          "0x0000001c: ADD byte ptr [RAX],AL",
+          "0x0000001e: ADD byte ptr [RAX],AL",
+          "0x00000020: ADD byte ptr [RAX],AL",
+          "0x00000023: ADD byte ptr [RAX],AL",
+          "0x00000025: ADD byte ptr [RAX],AL",
+          "0x00000027: ADD byte ptr [RAX + 0x39],AL",
+          "0x0000002d: ADD byte ptr [RAX],AL",
+          "0x0000002f: ADD byte ptr [RAX],AL",
+          "0x00000031: ADD byte ptr [RAX],AL",
+          "0x00000033: ADD byte ptr [RAX],AL",
+          "0x00000036: CMP byte ptr [RAX],AL",
+          "0x00000038: OR EAX,0x1f004000",
+          "0x0000003d: ADD byte ptr [RSI],BL",
+          "0x0000003f: ADD byte ptr [RSI],AL",
+          "0x00000041: ADD byte ptr [RAX],AL",
+          "0x00000043: ADD byte ptr [RAX + RAX*0x1],AL",
+          "0x00000046: ADD byte ptr [RAX],AL",
+          "0x00000048: ADD byte ptr [RAX],AL",
+          "0x0000004b: ADD byte ptr [RAX],AL",
+          "0x0000004d: ADD byte ptr [RAX],AL",
+          "0x0000004f: ADD byte ptr [RAX],AL",
+          "0x00000052: ADD byte ptr [RAX],AL",
+          "0x00000054: ADD byte ptr [RAX],AL",
+          "0x00000056: ADD byte ptr [RAX],AL",
+          "0x00000058: ADD byte ptr [RAX],AL",
+          "0x0000005b: ADD byte ptr [RAX],AL",
+          "0x0000005d: ADD byte ptr [RAX],AL",
+          "0x0000005f: ADD AL,BL",
+          "0x00000061: ADD AL,byte ptr [RAX]",
+          "0x00000063: ADD byte ptr [RAX],AL",
+          "0x00000065: ADD byte ptr [RAX],AL",
+          "0x00000067: ADD AL,BL",
+          "0x00000069: ADD AL,byte ptr [RAX]",
+          "0x0000006b: ADD byte ptr [RAX],AL",
+          "0x0000006d: ADD byte ptr [RAX],AL",
+          "0x0000006f: ADD byte ptr [RAX],CL",
+          "0x00000071: ADD byte ptr [RAX],AL",
+          "0x00000073: ADD byte ptr [RAX],AL",
+          "0x00000075: ADD byte ptr [RAX],AL",
+          "0x00000077: ADD byte ptr [RBX],AL",
+          "0x00000079: ADD byte ptr [RAX],AL"
+        ],
+        "bb_info": {
+          "addr": 2,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            2,
+            6,
+            8,
+            10,
+            12,
+            14,
+            16,
+            18,
+            21,
+            23,
+            26,
+            28,
+            30,
+            32,
+            35,
+            37,
+            39,
+            45,
+            47,
+            49,
+            51,
+            54,
+            56,
+            61,
+            63,
+            65,
+            67,
+            70,
+            72,
+            75,
+            77,
+            79,
+            82,
+            84,
+            86,
+            88,
+            91,
+            93,
+            95,
+            97,
+            99,
+            101,
+            103,
+            105,
+            107,
+            109,
+            111,
+            113,
+            115,
+            117,
+            119,
+            121,
+            123
+          ],
+          "jump": 126,
+          "ninstr": 53,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 124,
+          "traced": false
+        },
+        "block_start_adr": 2,
+        "pcode": [
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "CF = INT_CARRY R8B, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "OF = INT_SCARRY R8B, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "R8B = INT_ADD R8B, (unique,0xbd00,1)",
+          "SF = INT_SLESS R8B, 0x0",
+          "ZF = INT_EQUAL R8B, 0x0",
+          "(unique,0x12e80,1) = INT_AND R8B, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0xbf00,4) = INT_ADD (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = STORE ram[RAX]",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0x12e80,4) = INT_AND (unique,0xbf00,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY EAX, (unique,0xbf00,4)",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY EAX, (unique,0xbf00,4)",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "EAX = INT_ADD EAX, (unique,0xbf00,4)",
+          "RAX = INT_ZEXT EAX",
+          "SF = INT_SLESS EAX, 0x0",
+          "ZF = INT_EQUAL EAX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EAX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RCX]",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3100,8) = INT_ADD RAX, 0x10",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3200,8) = INT_ADD RAX, 0x39",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_LESS (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SBORROW (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x29200,1) = INT_SUB (unique,0xbd00,1), AL",
+          "SF = INT_SLESS (unique,0x29200,1), 0x0",
+          "ZF = INT_EQUAL (unique,0x29200,1), 0x0",
+          "(unique,0x12e80,1) = INT_AND (unique,0x29200,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "EAX = INT_OR EAX, 0x1f004000",
+          "RAX = INT_ZEXT EAX",
+          "SF = INT_SLESS EAX, 0x0",
+          "ZF = INT_EQUAL EAX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EAX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "CF = INT_CARRY (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = STORE ram[RSI]",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RSI]",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3300,8) = INT_MULT RAX, 0x1",
+          "(unique,0x3400,8) = INT_ADD RAX, (unique,0x3300,8)",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3400,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3400,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY AL, BL",
+          "OF = INT_SCARRY AL, BL",
+          "AL = INT_ADD AL, BL",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY AL, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY AL, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "AL = INT_ADD AL, (unique,0xbd00,1)",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY AL, BL",
+          "OF = INT_SCARRY AL, BL",
+          "AL = INT_ADD AL, BL",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY AL, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY AL, (unique,0xbd00,1)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "AL = INT_ADD AL, (unique,0xbd00,1)",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), CL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), CL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), CL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RBX]",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0"
+        ]
+      },
+      {
+        "asm": [
+          "0x00000047: ADD byte ptr [RAX],AL",
+          "0x0000004a: ADD byte ptr [RAX],AL",
+          "0x0000004c: ADD byte ptr [RAX],AL",
+          "0x0000004e: ADD byte ptr [RAX],AL",
+          "0x00000050: ADD byte ptr [RAX],AL",
+          "0x00000053: ADD byte ptr [RAX],AL",
+          "0x00000055: ADD byte ptr [RAX],AL",
+          "0x00000057: ADD byte ptr [RAX],AL",
+          "0x0000005a: ADD byte ptr [RAX],AL",
+          "0x0000005c: ADD byte ptr [RAX],AL",
+          "0x0000005e: ADD byte ptr [RAX],AL",
+          "0x00000060: FADD dword ptr [RDX]",
+          "0x00000062: ADD byte ptr [RAX],AL",
+          "0x00000064: ADD byte ptr [RAX],AL",
+          "0x00000066: ADD byte ptr [RAX],AL",
+          "0x00000068: FADD dword ptr [RDX]",
+          "0x0000006a: ADD byte ptr [RAX],AL",
+          "0x0000006c: ADD byte ptr [RAX],AL",
+          "0x0000006e: ADD byte ptr [RAX],AL",
+          "0x00000070: OR byte ptr [RAX],AL",
+          "0x00000072: ADD byte ptr [RAX],AL",
+          "0x00000074: ADD byte ptr [RAX],AL",
+          "0x00000076: ADD byte ptr [RAX],AL",
+          "0x00000078: ADD EAX,dword ptr [RAX]",
+          "0x0000007a: ADD byte ptr [RAX],AL",
+          "0x0000007c: ADD AL,0x0"
+        ],
+        "bb_info": {
+          "addr": 71,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            71,
+            74,
+            76,
+            78,
+            80,
+            83,
+            85,
+            87,
+            90,
+            92,
+            94,
+            96,
+            98,
+            100,
+            102,
+            104,
+            106,
+            108,
+            110,
+            112,
+            114,
+            116,
+            118,
+            120,
+            122,
+            124
+          ],
+          "jump": 126,
+          "ninstr": 26,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 55,
+          "traced": false
+        },
+        "block_start_adr": 71,
+        "pcode": [
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x5700,4) = LOAD ram[RDX]",
+          "(unique,0x5da80,10) = FLOAT2FLOAT (unique,0x5700,4)",
+          "ST0 = FLOAT_ADD ST0, (unique,0x5da80,10)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x5700,4) = LOAD ram[RDX]",
+          "(unique,0x5da80,10) = FLOAT2FLOAT (unique,0x5700,4)",
+          "ST0 = FLOAT_ADD ST0, (unique,0x5da80,10)",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = COPY 0x0",
+          "OF = COPY 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_OR (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY EAX, (unique,0xbf00,4)",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY EAX, (unique,0xbf00,4)",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "EAX = INT_ADD EAX, (unique,0xbf00,4)",
+          "RAX = INT_ZEXT EAX",
+          "SF = INT_SLESS EAX, 0x0",
+          "ZF = INT_EQUAL EAX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EAX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY AL, 0x0",
+          "OF = INT_SCARRY AL, 0x0",
+          "AL = INT_ADD AL, 0x0",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0"
+        ]
+      },
+      {
+        "asm": [
+          "0x0000007e: ADD byte ptr [RAX],AL",
+          "0x00000080: SBB byte ptr [RBX],AL",
+          "0x00000082: ADD byte ptr [RAX],AL",
+          "0x00000084: ADD byte ptr [RAX],AL",
+          "0x00000086: ADD byte ptr [RAX],AL",
+          "0x00000088: SBB byte ptr [RBX],AL",
+          "0x0000008a: ADD byte ptr [RAX],AL",
+          "0x0000008c: ADD byte ptr [RAX],AL",
+          "0x0000008e: ADD byte ptr [RAX],AL",
+          "0x00000090: SBB byte ptr [RBX],AL",
+          "0x00000092: ADD byte ptr [RAX],AL",
+          "0x00000094: ADD byte ptr [RAX],AL",
+          "0x00000096: ADD byte ptr [RAX],AL",
+          "0x00000098: SBB AL,0x0",
+          "0x0000009a: ADD byte ptr [RAX],AL",
+          "0x0000009c: ADD byte ptr [RAX],AL",
+          "0x0000009e: ADD byte ptr [RAX],AL",
+          "0x000000a0: SBB AL,0x0",
+          "0x000000a2: ADD byte ptr [RAX],AL",
+          "0x000000a4: ADD byte ptr [RAX],AL",
+          "0x000000a6: ADD byte ptr [RAX],AL",
+          "0x000000a8: ADD dword ptr [RAX],EAX",
+          "0x000000aa: ADD byte ptr [RAX],AL",
+          "0x000000ac: ADD byte ptr [RAX],AL",
+          "0x000000ae: ADD byte ptr [RAX],AL",
+          "0x000000b0: ADD dword ptr [RAX],EAX",
+          "0x000000b2: ADD byte ptr [RAX],AL",
+          "0x000000b4: ADD AL,0x0",
+          "0x000000b6: ADD byte ptr [RAX],AL",
+          "0x000000b8: ADD byte ptr [RAX],AL",
+          "0x000000ba: ADD byte ptr [RAX],AL",
+          "0x000000bc: ADD byte ptr [RAX],AL",
+          "0x000000be: ADD byte ptr [RAX],AL",
+          "0x000000c0: ADD byte ptr [RAX],AL",
+          "0x000000c2: ADD byte ptr [RAX],AL",
+          "0x000000c4: ADD byte ptr [RAX],AL",
+          "0x000000c6: ADD byte ptr [RAX],AL",
+          "0x000000c8: ADD byte ptr [RAX],AL",
+          "0x000000ca: ADD byte ptr [RAX],AL",
+          "0x000000cc: ADD byte ptr [RAX],AL",
+          "0x000000ce: ADD byte ptr [RAX],AL",
+          "0x000000d0: ADD byte ptr [RSI],AL",
+          "0x000000d2: ADD byte ptr [RAX],AL",
+          "0x000000d4: ADD byte ptr [RAX],AL",
+          "0x000000d6: ADD byte ptr [RAX],AL",
+          "0x000000d8: ADD byte ptr [RSI],AL",
+          "0x000000da: ADD byte ptr [RAX],AL",
+          "0x000000dc: ADD byte ptr [RAX],AL",
+          "0x000000de: ADD byte ptr [RAX],AL",
+          "0x000000e0: ADD byte ptr [RAX],DL",
+          "0x000000e2: ADD byte ptr [RAX],AL",
+          "0x000000e4: ADD byte ptr [RAX],AL",
+          "0x000000e6: ADD byte ptr [RAX],AL",
+          "0x000000e8: ADD dword ptr [RAX],EAX",
+          "0x000000ea: ADD byte ptr [RAX],AL",
+          "0x000000ec: ADD EAX,0x0",
+          "0x000000f1: ADC byte ptr [RAX],AL",
+          "0x000000f3: ADD byte ptr [RAX],AL",
+          "0x000000f5: ADD byte ptr [RAX],AL",
+          "0x000000f7: ADD byte ptr [RAX],AL",
+          "0x000000f9: ADC byte ptr [RAX],AL",
+          "0x000000fb: ADD byte ptr [RAX],AL",
+          "0x000000fd: ADD byte ptr [RAX],AL",
+          "0x000000ff: ADD byte ptr [RAX],AL",
+          "0x00000101: ADC byte ptr [RAX],AL",
+          "0x00000103: ADD byte ptr [RAX],AL",
+          "0x00000105: ADD byte ptr [RAX],AL",
+          "0x00000107: ADD byte ptr [RBP + 0x2],DH",
+          "0x0000010a: ADD byte ptr [RAX],AL",
+          "0x0000010c: ADD byte ptr [RAX],AL",
+          "0x0000010e: ADD byte ptr [RAX],AL",
+          "0x00000110: JNZ 0x114"
+        ],
+        "bb_info": {
+          "addr": 126,
+          "fail": 274,
+          "inputs": 2,
+          "instrs": [
+            126,
+            128,
+            130,
+            132,
+            134,
+            136,
+            138,
+            140,
+            142,
+            144,
+            146,
+            148,
+            150,
+            152,
+            154,
+            156,
+            158,
+            160,
+            162,
+            164,
+            166,
+            168,
+            170,
+            172,
+            174,
+            176,
+            178,
+            180,
+            182,
+            184,
+            186,
+            188,
+            190,
+            192,
+            194,
+            196,
+            198,
+            200,
+            202,
+            204,
+            206,
+            208,
+            210,
+            212,
+            214,
+            216,
+            218,
+            220,
+            222,
+            224,
+            226,
+            228,
+            230,
+            232,
+            234,
+            236,
+            241,
+            243,
+            245,
+            247,
+            249,
+            251,
+            253,
+            255,
+            257,
+            259,
+            261,
+            263,
+            266,
+            268,
+            270,
+            272
+          ],
+          "jump": 276,
+          "ninstr": 72,
+          "opaddr": 18446744073709551615,
+          "outputs": 2,
+          "size": 148,
+          "traced": false
+        },
+        "block_start_adr": 126,
+        "pcode": [
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12880,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "CF = INT_LESS (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "OF = INT_SBORROW (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12a80,1) = INT_SUB (unique,0xbd00,1), AL",
+          "(unique,0x12b00,1) = INT_LESS (unique,0x12a80,1), (unique,0x12880,1)",
+          "CF = BOOL_OR CF, (unique,0x12b00,1)",
+          "(unique,0x12c00,1) = INT_SBORROW (unique,0x12a80,1), (unique,0x12880,1)",
+          "OF = BOOL_XOR OF, (unique,0x12c00,1)",
+          "(unique,0xbd00,1) = INT_SUB (unique,0x12a80,1), (unique,0x12880,1)",
+          "(unique,0xbd00,1) = STORE ram[RBX]",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12880,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "CF = INT_LESS (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "OF = INT_SBORROW (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12a80,1) = INT_SUB (unique,0xbd00,1), AL",
+          "(unique,0x12b00,1) = INT_LESS (unique,0x12a80,1), (unique,0x12880,1)",
+          "CF = BOOL_OR CF, (unique,0x12b00,1)",
+          "(unique,0x12c00,1) = INT_SBORROW (unique,0x12a80,1), (unique,0x12880,1)",
+          "OF = BOOL_XOR OF, (unique,0x12c00,1)",
+          "(unique,0xbd00,1) = INT_SUB (unique,0x12a80,1), (unique,0x12880,1)",
+          "(unique,0xbd00,1) = STORE ram[RBX]",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12880,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "CF = INT_LESS (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "OF = INT_SBORROW (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12a80,1) = INT_SUB (unique,0xbd00,1), AL",
+          "(unique,0x12b00,1) = INT_LESS (unique,0x12a80,1), (unique,0x12880,1)",
+          "CF = BOOL_OR CF, (unique,0x12b00,1)",
+          "(unique,0x12c00,1) = INT_SBORROW (unique,0x12a80,1), (unique,0x12880,1)",
+          "OF = BOOL_XOR OF, (unique,0x12c00,1)",
+          "(unique,0xbd00,1) = INT_SUB (unique,0x12a80,1), (unique,0x12880,1)",
+          "(unique,0xbd00,1) = STORE ram[RBX]",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RBX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12880,1) = COPY CF",
+          "CF = INT_LESS AL, 0x0",
+          "OF = INT_SBORROW AL, 0x0",
+          "(unique,0x12a80,1) = INT_SUB AL, 0x0",
+          "(unique,0x12b00,1) = INT_LESS (unique,0x12a80,1), (unique,0x12880,1)",
+          "CF = BOOL_OR CF, (unique,0x12b00,1)",
+          "(unique,0x12c00,1) = INT_SBORROW (unique,0x12a80,1), (unique,0x12880,1)",
+          "OF = BOOL_XOR OF, (unique,0x12c00,1)",
+          "AL = INT_SUB (unique,0x12a80,1), (unique,0x12880,1)",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12880,1) = COPY CF",
+          "CF = INT_LESS AL, 0x0",
+          "OF = INT_SBORROW AL, 0x0",
+          "(unique,0x12a80,1) = INT_SUB AL, 0x0",
+          "(unique,0x12b00,1) = INT_LESS (unique,0x12a80,1), (unique,0x12880,1)",
+          "CF = BOOL_OR CF, (unique,0x12b00,1)",
+          "(unique,0x12c00,1) = INT_SBORROW (unique,0x12a80,1), (unique,0x12880,1)",
+          "OF = BOOL_XOR OF, (unique,0x12c00,1)",
+          "AL = INT_SUB (unique,0x12a80,1), (unique,0x12880,1)",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0xbf00,4) = INT_ADD (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = STORE ram[RAX]",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0x12e80,4) = INT_AND (unique,0xbf00,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0xbf00,4) = INT_ADD (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = STORE ram[RAX]",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0x12e80,4) = INT_AND (unique,0xbf00,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY AL, 0x0",
+          "OF = INT_SCARRY AL, 0x0",
+          "AL = INT_ADD AL, 0x0",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RSI]",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RSI]",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0xbf00,4) = INT_ADD (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = STORE ram[RAX]",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0x12e80,4) = INT_AND (unique,0xbf00,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY EAX, 0x0",
+          "OF = INT_SCARRY EAX, 0x0",
+          "EAX = INT_ADD EAX, 0x0",
+          "RAX = INT_ZEXT EAX",
+          "SF = INT_SLESS EAX, 0x0",
+          "ZF = INT_EQUAL EAX, 0x0",
+          "(unique,0x12e80,4) = INT_AND EAX, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12300,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12500,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0x12580,1) = INT_CARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "CF = BOOL_OR CF, (unique,0x12580,1)",
+          "(unique,0x12680,1) = INT_SCARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "OF = BOOL_XOR OF, (unique,0x12680,1)",
+          "(unique,0xbd00,1) = INT_ADD (unique,0x12500,1), (unique,0x12300,1)",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12300,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12500,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0x12580,1) = INT_CARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "CF = BOOL_OR CF, (unique,0x12580,1)",
+          "(unique,0x12680,1) = INT_SCARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "OF = BOOL_XOR OF, (unique,0x12680,1)",
+          "(unique,0xbd00,1) = INT_ADD (unique,0x12500,1), (unique,0x12300,1)",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12300,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12500,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0x12580,1) = INT_CARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "CF = BOOL_OR CF, (unique,0x12580,1)",
+          "(unique,0x12680,1) = INT_SCARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "OF = BOOL_XOR OF, (unique,0x12680,1)",
+          "(unique,0xbd00,1) = INT_ADD (unique,0x12500,1), (unique,0x12300,1)",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3100,8) = INT_ADD RBP, 0x2",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), DH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), DH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), DH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xc900,1) = BOOL_NEGATE ZF",
+          "CBRANCH qword_ptr(0x00000114), (unique,0xc900,1)"
+        ]
+      },
+      {
+        "asm": [
+          "0x00000112: ADD byte ptr [RAX],AL"
+        ],
+        "bb_info": {
+          "addr": 274,
+          "fail": null,
+          "inputs": 1,
+          "instrs": [
+            274
+          ],
+          "jump": 276,
+          "ninstr": 1,
+          "opaddr": 18446744073709551615,
+          "outputs": 1,
+          "size": 2,
+          "traced": false
+        },
+        "block_start_adr": 274,
+        "pcode": [
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0"
+        ]
+      },
+      {
+        "asm": [
+          "0x00000114: ADD byte ptr [RAX],AL",
+          "0x00000116: ADD byte ptr [RAX],AL",
+          "0x00000118: ADD byte ptr [RAX],DL",
+          "0x0000011a: ADD byte ptr [RAX],AL",
+          "0x0000011c: ADD byte ptr [RAX],AL",
+          "0x0000011e: ADD byte ptr [RAX],AL",
+          "0x00000120: ADD dword ptr [RAX],EAX",
+          "0x00000122: ADD byte ptr [RAX],AL",
+          "0x00000124: ADD AL,0x0",
+          "0x00000126: ADD byte ptr [RAX],AL",
+          "0x00000128: ADD byte ptr [RAX],AH",
+          "0x0000012a: ADD byte ptr [RAX],AL",
+          "0x0000012c: ADD byte ptr [RAX],AL",
+          "0x0000012e: ADD byte ptr [RAX],AL",
+          "0x00000130: ADD byte ptr [RAX],AH",
+          "0x00000132: ADD byte ptr [RAX],AL",
+          "0x00000134: ADD byte ptr [RAX],AL",
+          "0x00000136: ADD byte ptr [RAX],AL",
+          "0x00000138: ADD byte ptr [RAX],AH",
+          "0x0000013a: ADD byte ptr [RAX],AL",
+          "0x0000013c: ADD byte ptr [RAX],AL",
+          "0x0000013e: ADD byte ptr [RAX],AL",
+          "0x00000140: MOV EAX,0x1",
+          "0x00000145: ADD byte ptr [RAX],AL",
+          "0x00000147: ADD byte ptr [RAX + 0x1],BH",
+          "0x0000014d: ADD byte ptr [RAX],AL",
+          "0x0000014f: ADD byte ptr [RAX],AL",
+          "0x00000151: ADC byte ptr [RAX],AL",
+          "0x00000153: ADD byte ptr [RAX],AL",
+          "0x00000155: ADD byte ptr [RAX],AL",
+          "0x00000157: ADD byte ptr [RCX],AL",
+          "0x00000159: ADD byte ptr [RAX],AL",
+          "0x0000015b: ADD byte ptr [RSI],AL",
+          "0x0000015d: ADD byte ptr [RAX],AL",
+          "0x0000015f: ADD byte ptr [RAX + 0x2d],BH",
+          "0x00000165: ADD byte ptr [RAX],AL",
+          "0x00000167: ADD byte ptr [RAX + 0x3d],BH",
+          "0x0000016d: ADD byte ptr [RAX],AL",
+          "0x0000016f: ADD byte ptr [RAX + 0x3d],BH",
+          "0x00000175: ADD byte ptr [RAX],AL",
+          "0x00000177: ADD byte ptr [RAX + 0x2],BL",
+          "0x0000017a: ADD byte ptr [RAX],AL",
+          "0x0000017c: ADD byte ptr [RAX],AL",
+          "0x0000017e: ADD byte ptr [RAX],AL"
+        ],
+        "bb_info": {
+          "addr": 276,
+          "fail": null,
+          "inputs": 2,
+          "instrs": [
+            276,
+            278,
+            280,
+            282,
+            284,
+            286,
+            288,
+            290,
+            292,
+            294,
+            296,
+            298,
+            300,
+            302,
+            304,
+            306,
+            308,
+            310,
+            312,
+            314,
+            316,
+            318,
+            320,
+            325,
+            327,
+            333,
+            335,
+            337,
+            339,
+            341,
+            343,
+            345,
+            347,
+            349,
+            351,
+            357,
+            359,
+            365,
+            367,
+            373,
+            375,
+            378,
+            380,
+            382
+          ],
+          "jump": null,
+          "ninstr": 44,
+          "opaddr": 18446744073709551615,
+          "outputs": 0,
+          "size": 108,
+          "traced": false
+        },
+        "block_start_adr": 276,
+        "pcode": [
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), DL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0xbf00,4) = INT_ADD (unique,0xbf00,4), EAX",
+          "(unique,0xbf00,4) = STORE ram[RAX]",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbf00,4), 0x0",
+          "(unique,0xbf00,4) = LOAD ram[RAX]",
+          "(unique,0x12e80,4) = INT_AND (unique,0xbf00,4), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,4)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "CF = INT_CARRY AL, 0x0",
+          "OF = INT_SCARRY AL, 0x0",
+          "AL = INT_ADD AL, 0x0",
+          "SF = INT_SLESS AL, 0x0",
+          "ZF = INT_EQUAL AL, 0x0",
+          "(unique,0x12e80,1) = INT_AND AL, 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AH",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "RAX = COPY 0x1",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3200,8) = INT_ADD RAX, 0x1",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x12300,1) = COPY CF",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12500,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0x12580,1) = INT_CARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "CF = BOOL_OR CF, (unique,0x12580,1)",
+          "(unique,0x12680,1) = INT_SCARRY (unique,0x12500,1), (unique,0x12300,1)",
+          "OF = BOOL_XOR OF, (unique,0x12680,1)",
+          "(unique,0xbd00,1) = INT_ADD (unique,0x12500,1), (unique,0x12300,1)",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RCX]",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RCX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RSI]",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RSI]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3200,8) = INT_ADD RAX, 0x2d",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3200,8) = INT_ADD RAX, 0x3d",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3200,8) = INT_ADD RAX, 0x3d",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BH",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3200,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3200,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0x3100,8) = INT_ADD RAX, 0x2",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "CF = INT_CARRY (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "OF = INT_SCARRY (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), BL",
+          "(unique,0xbd00,1) = STORE ram[(unique,0x3100,8)]",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[(unique,0x3100,8)]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "CF = INT_CARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "OF = INT_SCARRY (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0xbd00,1) = INT_ADD (unique,0xbd00,1), AL",
+          "(unique,0xbd00,1) = STORE ram[RAX]",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "SF = INT_SLESS (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "ZF = INT_EQUAL (unique,0xbd00,1), 0x0",
+          "(unique,0xbd00,1) = LOAD ram[RAX]",
+          "(unique,0x12e80,1) = INT_AND (unique,0xbd00,1), 0xff",
+          "(unique,0x12f00,1) = POPCOUNT (unique,0x12e80,1)",
+          "(unique,0x12f80,1) = INT_AND (unique,0x12f00,1), 0x1",
+          "PF = INT_EQUAL (unique,0x12f80,1), 0x0"
+        ]
+      }
+    ]
+  }
+]
\ No newline at end of file