From 7435218999af438ed7a5a8061ba669ae2b851f31 Mon Sep 17 00:00:00 2001
From: mlokr <jdoka@crownsterling.io>
Date: Sat, 11 May 2024 12:51:32 +0200
Subject: [PATCH] fixing relative jumps to not offset from immidiate adress but
 from instruction adress

---
 hblang/build.rs                               | 207 +++---
 hblang/examples/variables.hb                  |   6 +
 hblang/src/codegen.rs                         | 225 ++++--
 hblang/src/instrs.rs                          | 640 +++++++++++-------
 hblang/src/lexer.rs                           |  14 +-
 hblang/src/lib.rs                             |  13 +-
 hblang/src/parser.rs                          |   4 +-
 .../hblang::codegen::tests::variables.txt     |   0
 hbvm/src/vmrun.rs                             |  22 +-
 9 files changed, 711 insertions(+), 420 deletions(-)
 create mode 100644 hblang/examples/variables.hb
 create mode 100644 hblang/tests/hblang::codegen::tests::variables.txt

diff --git a/hblang/build.rs b/hblang/build.rs
index 9f72d18..f61acbb 100644
--- a/hblang/build.rs
+++ b/hblang/build.rs
@@ -1,95 +1,136 @@
 #![feature(iter_next_chunk)]
+use std::fmt::Write;
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-changed=../hbbytecode/instructions.in");
 
-    let instructions = include_str!("../hbbytecode/instructions.in");
-
     let mut generated = String::new();
-    use std::fmt::Write;
 
-    writeln!(&mut generated, "impl crate::codegen::Func {{")?;
-
-    for line in instructions.lines() {
-        let line = line.strip_suffix(";").unwrap();
-        let [opcode, name, ty, doc] = line.splitn(4, ',').map(str::trim).next_chunk().unwrap();
-
-        writeln!(&mut generated, "/// {}", doc.trim_matches('"'))?;
-        write!(&mut generated, "pub fn {}(&mut self", name.to_lowercase())?;
-        for (i, c) in ty.chars().enumerate() {
-            let (name, ty) = match c {
-                'N' => continue,
-                'R' => ("reg", "u8"),
-                'B' => ("imm", "u8"),
-                'H' => ("imm", "u16"),
-                'W' => ("imm", "u32"),
-                'D' => ("imm", "u64"),
-                'P' => ("offset", "u32"),
-                'O' => ("offset", "u32"),
-                'A' => ("addr", "u64"),
-                _ => panic!("unknown type: {}", c),
-            };
-            write!(&mut generated, ", {name}{i}: {ty}")?;
-        }
-        writeln!(&mut generated, ") {{")?;
-
-        let mut offset = 1;
-        for (i, c) in ty.chars().enumerate() {
-            let width = match c {
-                'N' => 0,
-                'R' => 1,
-                'B' => 1,
-                'H' => 2,
-                'W' => 4,
-                'D' => 8,
-                'A' => 8,
-                'P' => 2,
-                'O' => 4,
-                _ => panic!("unknown type: {}", c),
-            };
-
-            if matches!(c, 'P' | 'O') {
-                writeln!(
-                    &mut generated,
-                    "    self.offset(offset{i}, {offset}, {width});",
-                )?;
-            }
-
-            offset += width;
-        }
-
-        write!(
-            &mut generated,
-            "    self.extend(crate::as_bytes(&crate::Args({opcode}"
-        )?;
-        for (i, c) in ty.chars().enumerate() {
-            let name = match c {
-                'N' => continue,
-                'R' => "reg",
-                'B' | 'H' | 'W' | 'D' => "imm",
-                'P' => "0u16",
-                'O' => "0u32",
-                'A' => "addr",
-                _ => panic!("unknown type: {}", c),
-            };
-
-            if matches!(c, 'P' | 'O') {
-                write!(&mut generated, ", {name}")?;
-            } else {
-                write!(&mut generated, ", {name}{i}")?;
-            }
-        }
-        for _ in ty.len() - (ty == "N") as usize..4 {
-            write!(&mut generated, ", ()")?;
-        }
-        writeln!(&mut generated, ")));")?;
-
-        writeln!(&mut generated, "}}")?;
-    }
-
-    writeln!(&mut generated, "}}")?;
+    gen_max_size(&mut generated)?;
+    gen_encodes(&mut generated)?;
+    gen_structs(&mut generated)?;
+    gen_name_list(&mut generated)?;
 
     std::fs::write("src/instrs.rs", generated)?;
 
     Ok(())
 }
+
+fn gen_name_list(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
+    writeln!(
+        generated,
+        "pub const NAMES: [&str; {}] = [",
+        instructions().count()
+    )?;
+    for [_, name, _, _] in instructions() {
+        writeln!(generated, "    \"{}\",", name.to_lowercase())?;
+    }
+    writeln!(generated, "];")?;
+
+    Ok(())
+}
+
+fn gen_max_size(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
+    let max = instructions()
+        .map(|[_, _, ty, _]| {
+            if ty == "N" {
+                1
+            } else {
+                iter_args(ty).map(|(_, c)| arg_to_width(c)).sum::<usize>() + 1
+            }
+        })
+        .max()
+        .unwrap();
+
+    writeln!(generated, "pub const MAX_SIZE: usize = {};", max)?;
+
+    Ok(())
+}
+
+fn gen_encodes(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
+    for [op, name, ty, doc] in instructions() {
+        writeln!(generated, "/// {}", doc.trim_matches('"'))?;
+        let name = name.to_lowercase();
+        let args = comma_sep(
+            iter_args(ty).map(|(i, c)| format!("{}{i}: {}", arg_to_name(c), arg_to_type(c))),
+        );
+        writeln!(
+            generated,
+            "pub fn {name}({args}) -> (usize, [u8; MAX_SIZE]) {{"
+        )?;
+        let arg_names = comma_sep(iter_args(ty).map(|(i, c)| format!("{}{i}", arg_to_name(c))));
+        writeln!(
+            generated,
+            "    unsafe {{ crate::encode({ty}({op}, {arg_names})) }}"
+        )?;
+        writeln!(generated, "}}")?;
+    }
+
+    Ok(())
+}
+
+fn gen_structs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
+    let mut seen = std::collections::HashSet::new();
+    for [_, _, ty, _] in instructions() {
+        if !seen.insert(ty) {
+            continue;
+        }
+        let types = comma_sep(iter_args(ty).map(|(_, c)| arg_to_type(c).to_string()));
+        writeln!(generated, "#[repr(packed)] pub struct {ty}(u8, {types});")?;
+    }
+
+    Ok(())
+}
+
+fn comma_sep(items: impl Iterator<Item = String>) -> String {
+    items
+        .map(|item| item.to_string())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+fn instructions() -> impl Iterator<Item = [&'static str; 4]> {
+    include_str!("../hbbytecode/instructions.in")
+        .lines()
+        .filter_map(|line| line.strip_suffix(';'))
+        .map(|line| line.splitn(4, ',').map(str::trim).next_chunk().unwrap())
+}
+
+fn arg_to_type(arg: char) -> &'static str {
+    match arg {
+        'R' | 'B' => "u8",
+        'H' => "u16",
+        'W' => "u32",
+        'D' | 'A' => "u64",
+        'P' => "i16",
+        'O' => "i32",
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn arg_to_width(arg: char) -> usize {
+    match arg {
+        'R' | 'B' => 1,
+        'H' => 2,
+        'W' => 4,
+        'D' | 'A' => 8,
+        'P' => 2,
+        'O' => 4,
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn arg_to_name(arg: char) -> &'static str {
+    match arg {
+        'R' => "reg",
+        'B' | 'H' | 'W' | 'D' => "imm",
+        'P' | 'O' => "offset",
+        'A' => "addr",
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn iter_args(ty: &'static str) -> impl Iterator<Item = (usize, char)> {
+    ty.chars().enumerate().filter(|(_, c)| *c != 'N')
+}
diff --git a/hblang/examples/variables.hb b/hblang/examples/variables.hb
new file mode 100644
index 0000000..fc4afe4
--- /dev/null
+++ b/hblang/examples/variables.hb
@@ -0,0 +1,6 @@
+main := ||: int {
+	a := 1;
+	b := 2;
+	a = a + 1;
+	return a - b;
+}
diff --git a/hblang/src/codegen.rs b/hblang/src/codegen.rs
index 9abc906..dc33360 100644
--- a/hblang/src/codegen.rs
+++ b/hblang/src/codegen.rs
@@ -1,6 +1,6 @@
 use {
     crate::{
-        lexer,
+        instrs, lexer,
         parser::{self, Expr},
     },
     std::rc::Rc,
@@ -27,6 +27,11 @@ struct Reloc {
     size:   u16,
 }
 
+struct StackReloc {
+    offset: u32,
+    size:   u16,
+}
+
 #[derive(Default)]
 pub struct Func {
     code:   Vec<u8>,
@@ -46,31 +51,48 @@ impl Func {
         });
     }
 
+    fn encode(&mut self, (len, instr): (usize, [u8; instrs::MAX_SIZE])) {
+        let name = instrs::NAMES[instr[0] as usize];
+        println!(
+            "{}: {}",
+            name,
+            instr
+                .iter()
+                .take(len)
+                .skip(1)
+                .map(|b| format!("{:02x}", b))
+                .collect::<String>()
+        );
+        self.code.extend_from_slice(&instr[..len]);
+    }
+
     fn push(&mut self, value: Reg, size: usize) {
-        self.st(value, STACK_PTR, 0, size as _);
-        self.addi64(STACK_PTR, STACK_PTR, size as _);
+        self.subi64(STACK_PTR, STACK_PTR, size as _);
+        self.encode(instrs::st(value, STACK_PTR, 0, size as _));
     }
 
     fn pop(&mut self, value: Reg, size: usize) {
-        self.addi64(STACK_PTR, STACK_PTR, (size as u64).wrapping_neg());
-        self.ld(value, STACK_PTR, 0, size as _);
+        self.encode(instrs::ld(value, STACK_PTR, 0, size as _));
+        self.encode(instrs::addi64(STACK_PTR, STACK_PTR, size as _));
+    }
+
+    fn subi64(&mut self, dest: Reg, src: Reg, imm: u64) {
+        self.encode(instrs::addi64(dest, src, imm.wrapping_neg()));
     }
 
     fn call(&mut self, func: LabelId) {
-        self.jal(RET_ADDR, ZERO, func);
+        self.offset(func, 3, 4);
+        self.encode(instrs::jal(RET_ADDR, ZERO, 0));
     }
 
     fn ret(&mut self) {
-        self.jala(ZERO, RET_ADDR, 0);
+        self.pop(RET_ADDR, 8);
+        self.encode(instrs::jala(ZERO, RET_ADDR, 0));
     }
 
     fn prelude(&mut self, entry: LabelId) {
         self.call(entry);
-        self.tx();
-    }
-
-    fn div64(&mut self, reg0: Reg, reg1: Reg, reg2: Reg) {
-        self.diru64(reg0, ZERO, reg1, reg2);
+        self.encode(instrs::tx());
     }
 
     fn relocate(&mut self, labels: &[Label], shift: i64) {
@@ -131,24 +153,38 @@ struct Label {
     name:   Rc<str>,
 }
 
+struct Variable<'a> {
+    name:   Rc<str>,
+    offset: u64,
+    ty:     Expr<'a>,
+}
+
 pub struct Codegen<'a> {
-    path:   &'a std::path::Path,
-    ret:    Expr<'a>,
-    gpa:    RegAlloc,
-    code:   Func,
-    temp:   Func,
-    labels: Vec<Label>,
+    path:       &'a std::path::Path,
+    ret:        Expr<'a>,
+    gpa:        RegAlloc,
+    code:       Func,
+    temp:       Func,
+    labels:     Vec<Label>,
+    stack_size: u64,
+    vars:       Vec<Variable<'a>>,
+
+    stack_relocs: Vec<StackReloc>,
 }
 
 impl<'a> Codegen<'a> {
     pub fn new() -> Self {
         Self {
-            path:   std::path::Path::new(""),
-            ret:    Expr::Return { val: None },
-            gpa:    Default::default(),
-            code:   Default::default(),
-            temp:   Default::default(),
-            labels: Default::default(),
+            path:       std::path::Path::new(""),
+            ret:        Expr::Return { val: None },
+            gpa:        Default::default(),
+            code:       Default::default(),
+            temp:       Default::default(),
+            labels:     Default::default(),
+            stack_size: 0,
+            vars:       Default::default(),
+
+            stack_relocs: Default::default(),
         }
     }
 
@@ -164,6 +200,53 @@ impl<'a> Codegen<'a> {
         Ok(())
     }
 
+    fn loc_to_reg(&mut self, loc: Loc) -> Reg {
+        match loc {
+            Loc::Reg(reg) => reg,
+            Loc::Imm(imm) => {
+                let reg = self.gpa.allocate();
+                self.code.encode(instrs::li64(reg, imm));
+                reg
+            }
+            Loc::Stack(offset) => {
+                let reg = self.gpa.allocate();
+                self.load_stack(reg, offset, 8);
+                reg
+            }
+        }
+    }
+
+    fn alloc_stack(&mut self, size: u32) -> u64 {
+        let offset = self.stack_size;
+        self.stack_size += size as u64;
+        offset
+    }
+
+    fn store_stack(&mut self, reg: Reg, offset: u64, size: u16) {
+        self.stack_relocs.push(StackReloc {
+            offset: self.code.code.len() as u32 + 3,
+            size,
+        });
+        self.code.encode(instrs::st(reg, STACK_PTR, offset, size));
+    }
+
+    fn load_stack(&mut self, reg: Reg, offset: u64, size: u16) {
+        self.stack_relocs.push(StackReloc {
+            offset: self.code.code.len() as u32 + 3,
+            size,
+        });
+        self.code.encode(instrs::ld(reg, STACK_PTR, offset, size));
+    }
+
+    fn reloc_stack(&mut self, stack_height: u64) {
+        for reloc in self.stack_relocs.drain(..) {
+            let dest = &mut self.code.code[reloc.offset as usize..][..reloc.size as usize];
+            let value = u64::from_ne_bytes(dest.try_into().unwrap());
+            let offset = stack_height - value;
+            dest.copy_from_slice(&offset.to_ne_bytes());
+        }
+    }
+
     fn expr(&mut self, expr: &'a parser::Expr<'a>, expeted: Option<Expr<'a>>) -> Option<Value<'a>> {
         use {lexer::TokenKind as T, parser::Expr as E};
         match *expr {
@@ -175,19 +258,39 @@ impl<'a> Codegen<'a> {
                 self.gpa.init_caller();
                 self.ret = **ret;
                 self.expr(body, None);
+                let stack = std::mem::take(&mut self.stack_size);
+                self.reloc_stack(stack);
                 self.write_fn_prelude(frame);
                 None
             }
+            E::Decl { name, val } => {
+                let val = self.expr(val, None).unwrap();
+                let reg = self.loc_to_reg(val.loc);
+                let offset = self.alloc_stack(8);
+                self.decl_var(name, offset, val.ty);
+                self.store_stack(reg, offset, 8);
+                None
+            }
+            E::Ident { name } => {
+                let var = self.vars.iter().find(|v| v.name.as_ref() == name).unwrap();
+                Some(Value {
+                    ty:  var.ty,
+                    loc: Loc::Stack(var.offset),
+                })
+            }
             E::Return { val } => {
                 if let Some(val) = val {
                     let val = self.expr(val, Some(self.ret)).unwrap();
                     if val.ty != self.ret {
                         panic!("expected {:?}, got {:?}", self.ret, val.ty);
                     }
-                    match val.loc {
-                        Loc::Reg(reg) => self.code.cp(1, reg),
-                        Loc::Imm(imm) => self.code.li64(1, imm),
-                    }
+                    self.assign(
+                        Value {
+                            ty:  self.ret,
+                            loc: Loc::Reg(1),
+                        },
+                        val,
+                    );
                 }
                 self.ret();
                 None
@@ -206,36 +309,19 @@ impl<'a> Codegen<'a> {
                 let left = self.expr(left, expeted).unwrap();
                 let right = self.expr(right, Some(left.ty)).unwrap();
 
-                type Op = fn(&mut Func, u8, u8, u8);
-                type ImmOp = fn(&mut Func, u8, u8, u64);
-
                 let op = match op {
-                    T::Plus => Func::add64 as Op,
-                    T::Minus => Func::sub64 as Op,
-                    T::Star => Func::mul64 as Op,
-                    T::FSlash => Func::div64 as Op,
+                    T::Plus => instrs::add64,
+                    T::Minus => instrs::sub64,
+                    T::Star => instrs::mul64,
+                    T::FSlash => |reg0, reg1, reg2| instrs::diru64(reg0, ZERO, reg1, reg2),
+                    T::Assign => return self.assign(left, right),
                     _ => unimplemented!("{:#?}", op),
                 };
 
-                let lhs = match left.loc {
-                    Loc::Reg(reg) => reg,
-                    Loc::Imm(imm) => {
-                        let reg = self.gpa.allocate();
-                        self.code.li64(reg, imm);
-                        reg
-                    }
-                };
+                let lhs = self.loc_to_reg(left.loc);
+                let rhs = self.loc_to_reg(right.loc);
 
-                let rhs = match right.loc {
-                    Loc::Reg(reg) => reg,
-                    Loc::Imm(imm) => {
-                        let reg = self.gpa.allocate();
-                        self.code.li64(reg, imm);
-                        reg
-                    }
-                };
-
-                op(&mut self.code, lhs, lhs, rhs);
+                self.code.encode(op(lhs, lhs, rhs));
                 self.gpa.free(rhs);
 
                 Some(Value {
@@ -247,6 +333,17 @@ impl<'a> Codegen<'a> {
         }
     }
 
+    fn assign(&mut self, left: Value<'a>, right: Value<'a>) -> Option<Value<'a>> {
+        let rhs = self.loc_to_reg(right.loc);
+        match left.loc {
+            Loc::Reg(reg) => self.code.encode(instrs::cp(reg, rhs)),
+            Loc::Stack(offset) => self.store_stack(rhs, offset, 8),
+            _ => unimplemented!(),
+        }
+        self.gpa.free(rhs);
+        Some(left)
+    }
+
     fn get_or_reserve_label(&mut self, name: &str) -> LabelId {
         if let Some(label) = self.labels.iter().position(|l| l.name.as_ref() == name) {
             label as u32
@@ -287,9 +384,11 @@ impl<'a> Codegen<'a> {
     }
 
     fn write_fn_prelude(&mut self, frame: Frame) {
+        self.temp.push(RET_ADDR, 8);
         for &reg in self.gpa.used.clone().iter() {
             self.temp.push(reg, 8);
         }
+        self.temp.subi64(STACK_PTR, STACK_PTR, self.stack_size as _);
 
         for reloc in &mut self.code.relocs[frame.prev_relocs..] {
             reloc.offset += self.temp.code.len() as u32;
@@ -302,6 +401,11 @@ impl<'a> Codegen<'a> {
     }
 
     fn ret(&mut self) {
+        self.stack_relocs.push(StackReloc {
+            offset: self.code.code.len() as u32 + 3,
+            size:   8,
+        });
+        self.code.encode(instrs::addi64(STACK_PTR, STACK_PTR, 0));
         for reg in self.gpa.used.clone().iter().rev() {
             self.code.pop(*reg, 8);
         }
@@ -317,6 +421,14 @@ impl<'a> Codegen<'a> {
         out.write_all(&self.temp.code)?;
         out.write_all(&self.code.code)
     }
+
+    fn decl_var(&mut self, name: &str, offset: u64, ty: Expr<'a>) {
+        self.vars.push(Variable {
+            name: name.into(),
+            offset,
+            ty,
+        });
+    }
 }
 
 pub struct Value<'a> {
@@ -327,6 +439,7 @@ pub struct Value<'a> {
 pub enum Loc {
     Reg(Reg),
     Imm(u64),
+    Stack(u64),
 }
 
 #[cfg(test)]
@@ -381,7 +494,10 @@ mod tests {
             hbvm::Vm::<TestMem, 0>::new(TestMem, hbvm::mem::Address::new(out.as_ptr() as u64))
         };
 
-        vm.write_reg(super::STACK_PTR, stack.as_mut_ptr() as u64);
+        vm.write_reg(
+            super::STACK_PTR,
+            unsafe { stack.as_mut_ptr().add(stack.len()) } as u64,
+        );
 
         let stat = loop {
             match vm.run() {
@@ -398,5 +514,6 @@ mod tests {
     crate::run_tests! { generate:
         example => include_str!("../examples/main_fn.hb");
         arithmetic => include_str!("../examples/arithmetic.hb");
+        variables => include_str!("../examples/variables.hb");
     }
 }
diff --git a/hblang/src/instrs.rs b/hblang/src/instrs.rs
index f45fdf6..934258f 100644
--- a/hblang/src/instrs.rs
+++ b/hblang/src/instrs.rs
@@ -1,497 +1,623 @@
-impl crate::codegen::Func {
+pub const MAX_SIZE: usize = 13;
 /// Cause an unreachable code trap
-pub fn un(&mut self) {
-    self.extend(crate::as_bytes(&crate::Args(0x00, (), (), (), ())));
+pub fn un() -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(N(0x00, )) }
 }
 /// Termiante execution
-pub fn tx(&mut self) {
-    self.extend(crate::as_bytes(&crate::Args(0x01, (), (), (), ())));
+pub fn tx() -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(N(0x01, )) }
 }
 /// Do nothing
-pub fn nop(&mut self) {
-    self.extend(crate::as_bytes(&crate::Args(0x02, (), (), (), ())));
+pub fn nop() -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(N(0x02, )) }
 }
 /// Addition (8b)
-pub fn add8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x03, reg0, reg1, reg2, ())));
+pub fn add8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x03, reg0, reg1, reg2)) }
 }
 /// Addition (16b)
-pub fn add16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x04, reg0, reg1, reg2, ())));
+pub fn add16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x04, reg0, reg1, reg2)) }
 }
 /// Addition (32b)
-pub fn add32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x05, reg0, reg1, reg2, ())));
+pub fn add32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x05, reg0, reg1, reg2)) }
 }
 /// Addition (64b)
-pub fn add64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x06, reg0, reg1, reg2, ())));
+pub fn add64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x06, reg0, reg1, reg2)) }
 }
 /// Subtraction (8b)
-pub fn sub8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x07, reg0, reg1, reg2, ())));
+pub fn sub8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x07, reg0, reg1, reg2)) }
 }
 /// Subtraction (16b)
-pub fn sub16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x08, reg0, reg1, reg2, ())));
+pub fn sub16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x08, reg0, reg1, reg2)) }
 }
 /// Subtraction (32b)
-pub fn sub32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x09, reg0, reg1, reg2, ())));
+pub fn sub32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x09, reg0, reg1, reg2)) }
 }
 /// Subtraction (64b)
-pub fn sub64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0A, reg0, reg1, reg2, ())));
+pub fn sub64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0A, reg0, reg1, reg2)) }
 }
 /// Multiplication (8b)
-pub fn mul8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0B, reg0, reg1, reg2, ())));
+pub fn mul8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0B, reg0, reg1, reg2)) }
 }
 /// Multiplication (16b)
-pub fn mul16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0C, reg0, reg1, reg2, ())));
+pub fn mul16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0C, reg0, reg1, reg2)) }
 }
 /// Multiplication (32b)
-pub fn mul32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0D, reg0, reg1, reg2, ())));
+pub fn mul32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0D, reg0, reg1, reg2)) }
 }
 /// Multiplication (64b)
-pub fn mul64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0E, reg0, reg1, reg2, ())));
+pub fn mul64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0E, reg0, reg1, reg2)) }
 }
 /// Bitand
-pub fn and(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x0F, reg0, reg1, reg2, ())));
+pub fn and(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x0F, reg0, reg1, reg2)) }
 }
 /// Bitor
-pub fn or(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x10, reg0, reg1, reg2, ())));
+pub fn or(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x10, reg0, reg1, reg2)) }
 }
 /// Bitxor
-pub fn xor(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x11, reg0, reg1, reg2, ())));
+pub fn xor(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x11, reg0, reg1, reg2)) }
 }
 /// Unsigned left bitshift (8b)
-pub fn slu8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x12, reg0, reg1, reg2, ())));
+pub fn slu8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x12, reg0, reg1, reg2)) }
 }
 /// Unsigned left bitshift (16b)
-pub fn slu16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x13, reg0, reg1, reg2, ())));
+pub fn slu16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x13, reg0, reg1, reg2)) }
 }
 /// Unsigned left bitshift (32b)
-pub fn slu32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x14, reg0, reg1, reg2, ())));
+pub fn slu32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x14, reg0, reg1, reg2)) }
 }
 /// Unsigned left bitshift (64b)
-pub fn slu64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x15, reg0, reg1, reg2, ())));
+pub fn slu64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x15, reg0, reg1, reg2)) }
 }
 /// Unsigned right bitshift (8b)
-pub fn sru8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x16, reg0, reg1, reg2, ())));
+pub fn sru8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x16, reg0, reg1, reg2)) }
 }
 /// Unsigned right bitshift (16b)
-pub fn sru16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x17, reg0, reg1, reg2, ())));
+pub fn sru16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x17, reg0, reg1, reg2)) }
 }
 /// Unsigned right bitshift (32b)
-pub fn sru32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x18, reg0, reg1, reg2, ())));
+pub fn sru32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x18, reg0, reg1, reg2)) }
 }
 /// Unsigned right bitshift (64b)
-pub fn sru64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x19, reg0, reg1, reg2, ())));
+pub fn sru64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x19, reg0, reg1, reg2)) }
 }
 /// Signed right bitshift (8b)
-pub fn srs8(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1A, reg0, reg1, reg2, ())));
+pub fn srs8(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1A, reg0, reg1, reg2)) }
 }
 /// Signed right bitshift (16b)
-pub fn srs16(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1B, reg0, reg1, reg2, ())));
+pub fn srs16(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1B, reg0, reg1, reg2)) }
 }
 /// Signed right bitshift (32b)
-pub fn srs32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1C, reg0, reg1, reg2, ())));
+pub fn srs32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1C, reg0, reg1, reg2)) }
 }
 /// Signed right bitshift (64b)
-pub fn srs64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1D, reg0, reg1, reg2, ())));
+pub fn srs64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1D, reg0, reg1, reg2)) }
 }
 /// Unsigned comparsion
-pub fn cmpu(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1E, reg0, reg1, reg2, ())));
+pub fn cmpu(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1E, reg0, reg1, reg2)) }
 }
 /// Signed comparsion
-pub fn cmps(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x1F, reg0, reg1, reg2, ())));
+pub fn cmps(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x1F, reg0, reg1, reg2)) }
 }
 /// Merged divide-remainder (unsigned 8b)
-pub fn diru8(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x20, reg0, reg1, reg2, reg3)));
+pub fn diru8(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x20, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (unsigned 16b)
-pub fn diru16(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x21, reg0, reg1, reg2, reg3)));
+pub fn diru16(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x21, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (unsigned 32b)
-pub fn diru32(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x22, reg0, reg1, reg2, reg3)));
+pub fn diru32(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x22, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (unsigned 64b)
-pub fn diru64(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x23, reg0, reg1, reg2, reg3)));
+pub fn diru64(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x23, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (signed 8b)
-pub fn dirs8(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x24, reg0, reg1, reg2, reg3)));
+pub fn dirs8(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x24, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (signed 16b)
-pub fn dirs16(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x25, reg0, reg1, reg2, reg3)));
+pub fn dirs16(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x25, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (signed 32b)
-pub fn dirs32(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x26, reg0, reg1, reg2, reg3)));
+pub fn dirs32(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x26, reg0, reg1, reg2, reg3)) }
 }
 /// Merged divide-remainder (signed 64b)
-pub fn dirs64(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x27, reg0, reg1, reg2, reg3)));
+pub fn dirs64(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x27, reg0, reg1, reg2, reg3)) }
 }
 /// Bit negation
-pub fn neg(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x28, reg0, reg1, (), ())));
+pub fn neg(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x28, reg0, reg1)) }
 }
 /// Logical negation
-pub fn not(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x29, reg0, reg1, (), ())));
+pub fn not(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x29, reg0, reg1)) }
 }
 /// Sign extend 8b to 64b
-pub fn sxt8(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x2A, reg0, reg1, (), ())));
+pub fn sxt8(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x2A, reg0, reg1)) }
 }
 /// Sign extend 16b to 64b
-pub fn sxt16(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x2B, reg0, reg1, (), ())));
+pub fn sxt16(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x2B, reg0, reg1)) }
 }
 /// Sign extend 32b to 64b
-pub fn sxt32(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x2C, reg0, reg1, (), ())));
+pub fn sxt32(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x2C, reg0, reg1)) }
 }
 /// Addition with immediate (8b)
-pub fn addi8(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x2D, reg0, reg1, imm2, ())));
+pub fn addi8(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x2D, reg0, reg1, imm2)) }
 }
 /// Addition with immediate (16b)
-pub fn addi16(&mut self, reg0: u8, reg1: u8, imm2: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x2E, reg0, reg1, imm2, ())));
+pub fn addi16(reg0: u8, reg1: u8, imm2: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRH(0x2E, reg0, reg1, imm2)) }
 }
 /// Addition with immediate (32b)
-pub fn addi32(&mut self, reg0: u8, reg1: u8, imm2: u32) {
-    self.extend(crate::as_bytes(&crate::Args(0x2F, reg0, reg1, imm2, ())));
+pub fn addi32(reg0: u8, reg1: u8, imm2: u32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRW(0x2F, reg0, reg1, imm2)) }
 }
 /// Addition with immediate (64b)
-pub fn addi64(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x30, reg0, reg1, imm2, ())));
+pub fn addi64(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x30, reg0, reg1, imm2)) }
 }
 /// Multiplication with immediate (8b)
-pub fn muli8(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x31, reg0, reg1, imm2, ())));
+pub fn muli8(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x31, reg0, reg1, imm2)) }
 }
 /// Multiplication with immediate (16b)
-pub fn muli16(&mut self, reg0: u8, reg1: u8, imm2: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x32, reg0, reg1, imm2, ())));
+pub fn muli16(reg0: u8, reg1: u8, imm2: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRH(0x32, reg0, reg1, imm2)) }
 }
 /// Multiplication with immediate (32b)
-pub fn muli32(&mut self, reg0: u8, reg1: u8, imm2: u32) {
-    self.extend(crate::as_bytes(&crate::Args(0x33, reg0, reg1, imm2, ())));
+pub fn muli32(reg0: u8, reg1: u8, imm2: u32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRW(0x33, reg0, reg1, imm2)) }
 }
 /// Multiplication with immediate (64b)
-pub fn muli64(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x34, reg0, reg1, imm2, ())));
+pub fn muli64(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x34, reg0, reg1, imm2)) }
 }
 /// Bitand with immediate
-pub fn andi(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x35, reg0, reg1, imm2, ())));
+pub fn andi(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x35, reg0, reg1, imm2)) }
 }
 /// Bitor with immediate
-pub fn ori(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x36, reg0, reg1, imm2, ())));
+pub fn ori(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x36, reg0, reg1, imm2)) }
 }
 /// Bitxor with immediate
-pub fn xori(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x37, reg0, reg1, imm2, ())));
+pub fn xori(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x37, reg0, reg1, imm2)) }
 }
 /// Unsigned left bitshift with immedidate (8b)
-pub fn slui8(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x38, reg0, reg1, imm2, ())));
+pub fn slui8(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x38, reg0, reg1, imm2)) }
 }
 /// Unsigned left bitshift with immedidate (16b)
-pub fn slui16(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x39, reg0, reg1, imm2, ())));
+pub fn slui16(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x39, reg0, reg1, imm2)) }
 }
 /// Unsigned left bitshift with immedidate (32b)
-pub fn slui32(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3A, reg0, reg1, imm2, ())));
+pub fn slui32(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3A, reg0, reg1, imm2)) }
 }
 /// Unsigned left bitshift with immedidate (64b)
-pub fn slui64(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3B, reg0, reg1, imm2, ())));
+pub fn slui64(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3B, reg0, reg1, imm2)) }
 }
 /// Unsigned right bitshift with immediate (8b)
-pub fn srui8(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3C, reg0, reg1, imm2, ())));
+pub fn srui8(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3C, reg0, reg1, imm2)) }
 }
 /// Unsigned right bitshift with immediate (16b)
-pub fn srui16(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3D, reg0, reg1, imm2, ())));
+pub fn srui16(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3D, reg0, reg1, imm2)) }
 }
 /// Unsigned right bitshift with immediate (32b)
-pub fn srui32(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3E, reg0, reg1, imm2, ())));
+pub fn srui32(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3E, reg0, reg1, imm2)) }
 }
 /// Unsigned right bitshift with immediate (64b)
-pub fn srui64(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x3F, reg0, reg1, imm2, ())));
+pub fn srui64(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x3F, reg0, reg1, imm2)) }
 }
 /// Signed right bitshift with immediate
-pub fn srsi8(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x40, reg0, reg1, imm2, ())));
+pub fn srsi8(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x40, reg0, reg1, imm2)) }
 }
 /// Signed right bitshift with immediate
-pub fn srsi16(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x41, reg0, reg1, imm2, ())));
+pub fn srsi16(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x41, reg0, reg1, imm2)) }
 }
 /// Signed right bitshift with immediate
-pub fn srsi32(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x42, reg0, reg1, imm2, ())));
+pub fn srsi32(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x42, reg0, reg1, imm2)) }
 }
 /// Signed right bitshift with immediate
-pub fn srsi64(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x43, reg0, reg1, imm2, ())));
+pub fn srsi64(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x43, reg0, reg1, imm2)) }
 }
 /// Unsigned compare with immediate
-pub fn cmpui(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x44, reg0, reg1, imm2, ())));
+pub fn cmpui(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x44, reg0, reg1, imm2)) }
 }
 /// Signed compare with immediate
-pub fn cmpsi(&mut self, reg0: u8, reg1: u8, imm2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x45, reg0, reg1, imm2, ())));
+pub fn cmpsi(reg0: u8, reg1: u8, imm2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRD(0x45, reg0, reg1, imm2)) }
 }
 /// Copy register
-pub fn cp(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x46, reg0, reg1, (), ())));
+pub fn cp(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x46, reg0, reg1)) }
 }
 /// Swap registers
-pub fn swa(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x47, reg0, reg1, (), ())));
+pub fn swa(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x47, reg0, reg1)) }
 }
 /// Load immediate (8b)
-pub fn li8(&mut self, reg0: u8, imm1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x48, reg0, imm1, (), ())));
+pub fn li8(reg0: u8, imm1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RB(0x48, reg0, imm1)) }
 }
 /// Load immediate (16b)
-pub fn li16(&mut self, reg0: u8, imm1: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x49, reg0, imm1, (), ())));
+pub fn li16(reg0: u8, imm1: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RH(0x49, reg0, imm1)) }
 }
 /// Load immediate (32b)
-pub fn li32(&mut self, reg0: u8, imm1: u32) {
-    self.extend(crate::as_bytes(&crate::Args(0x4A, reg0, imm1, (), ())));
+pub fn li32(reg0: u8, imm1: u32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RW(0x4A, reg0, imm1)) }
 }
 /// Load immediate (64b)
-pub fn li64(&mut self, reg0: u8, imm1: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x4B, reg0, imm1, (), ())));
+pub fn li64(reg0: u8, imm1: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RD(0x4B, reg0, imm1)) }
 }
 /// Load relative address
-pub fn lra(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 4);
-    self.extend(crate::as_bytes(&crate::Args(0x4C, reg0, reg1, 0u32, ())));
+pub fn lra(reg0: u8, reg1: u8, offset2: i32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRO(0x4C, reg0, reg1, offset2)) }
 }
 /// Load from absolute address
-pub fn ld(&mut self, reg0: u8, reg1: u8, addr2: u64, imm3: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x4D, reg0, reg1, addr2, imm3)));
+pub fn ld(reg0: u8, reg1: u8, addr2: u64, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRAH(0x4D, reg0, reg1, addr2, imm3)) }
 }
 /// Store to absolute address
-pub fn st(&mut self, reg0: u8, reg1: u8, addr2: u64, imm3: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x4E, reg0, reg1, addr2, imm3)));
+pub fn st(reg0: u8, reg1: u8, addr2: u64, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRAH(0x4E, reg0, reg1, addr2, imm3)) }
 }
 /// Load from relative address
-pub fn ldr(&mut self, reg0: u8, reg1: u8, offset2: u32, imm3: u16) {
-    self.offset(offset2, 3, 4);
-    self.extend(crate::as_bytes(&crate::Args(0x4F, reg0, reg1, 0u32, imm3)));
+pub fn ldr(reg0: u8, reg1: u8, offset2: i32, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RROH(0x4F, reg0, reg1, offset2, imm3)) }
 }
 /// Store to relative address
-pub fn str(&mut self, reg0: u8, reg1: u8, offset2: u32, imm3: u16) {
-    self.offset(offset2, 3, 4);
-    self.extend(crate::as_bytes(&crate::Args(0x50, reg0, reg1, 0u32, imm3)));
+pub fn str(reg0: u8, reg1: u8, offset2: i32, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RROH(0x50, reg0, reg1, offset2, imm3)) }
 }
 /// Copy block of memory
-pub fn bmc(&mut self, reg0: u8, reg1: u8, imm2: u16) {
-    self.extend(crate::as_bytes(&crate::Args(0x51, reg0, reg1, imm2, ())));
+pub fn bmc(reg0: u8, reg1: u8, imm2: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRH(0x51, reg0, reg1, imm2)) }
 }
 /// Copy register block
-pub fn brc(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x52, reg0, reg1, imm2, ())));
+pub fn brc(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x52, reg0, reg1, imm2)) }
 }
 /// Relative jump
-pub fn jmp(&mut self, offset0: u32) {
-    self.offset(offset0, 1, 4);
-    self.extend(crate::as_bytes(&crate::Args(0x53, 0u32, (), (), ())));
+pub fn jmp(offset0: i32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(O(0x53, offset0)) }
 }
 /// Linking relative jump
-pub fn jal(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 4);
-    self.extend(crate::as_bytes(&crate::Args(0x54, reg0, reg1, 0u32, ())));
+pub fn jal(reg0: u8, reg1: u8, offset2: i32) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRO(0x54, reg0, reg1, offset2)) }
 }
 /// Linking absolute jump
-pub fn jala(&mut self, reg0: u8, reg1: u8, addr2: u64) {
-    self.extend(crate::as_bytes(&crate::Args(0x55, reg0, reg1, addr2, ())));
+pub fn jala(reg0: u8, reg1: u8, addr2: u64) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRA(0x55, reg0, reg1, addr2)) }
 }
 /// Branch on equal
-pub fn jeq(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x56, reg0, reg1, 0u16, ())));
+pub fn jeq(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x56, reg0, reg1, offset2)) }
 }
 /// Branch on nonequal
-pub fn jne(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x57, reg0, reg1, 0u16, ())));
+pub fn jne(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x57, reg0, reg1, offset2)) }
 }
 /// Branch on lesser-than (unsigned)
-pub fn jltu(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x58, reg0, reg1, 0u16, ())));
+pub fn jltu(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x58, reg0, reg1, offset2)) }
 }
 /// Branch on greater-than (unsigned)
-pub fn jgtu(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x59, reg0, reg1, 0u16, ())));
+pub fn jgtu(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x59, reg0, reg1, offset2)) }
 }
 /// Branch on lesser-than (signed)
-pub fn jlts(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x5A, reg0, reg1, 0u16, ())));
+pub fn jlts(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x5A, reg0, reg1, offset2)) }
 }
 /// Branch on greater-than (signed)
-pub fn jgts(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x5B, reg0, reg1, 0u16, ())));
+pub fn jgts(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x5B, reg0, reg1, offset2)) }
 }
 /// Environment call trap
-pub fn eca(&mut self) {
-    self.extend(crate::as_bytes(&crate::Args(0x5C, (), (), (), ())));
+pub fn eca() -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(N(0x5C, )) }
 }
 /// Environment breakpoint
-pub fn ebp(&mut self) {
-    self.extend(crate::as_bytes(&crate::Args(0x5D, (), (), (), ())));
+pub fn ebp() -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(N(0x5D, )) }
 }
 /// Floating point addition (32b)
-pub fn fadd32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x5E, reg0, reg1, reg2, ())));
+pub fn fadd32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x5E, reg0, reg1, reg2)) }
 }
 /// Floating point addition (64b)
-pub fn fadd64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x5F, reg0, reg1, reg2, ())));
+pub fn fadd64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x5F, reg0, reg1, reg2)) }
 }
 /// Floating point subtraction (32b)
-pub fn fsub32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x60, reg0, reg1, reg2, ())));
+pub fn fsub32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x60, reg0, reg1, reg2)) }
 }
 /// Floating point subtraction (64b)
-pub fn fsub64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x61, reg0, reg1, reg2, ())));
+pub fn fsub64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x61, reg0, reg1, reg2)) }
 }
 /// Floating point multiply (32b)
-pub fn fmul32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x62, reg0, reg1, reg2, ())));
+pub fn fmul32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x62, reg0, reg1, reg2)) }
 }
 /// Floating point multiply (64b)
-pub fn fmul64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x63, reg0, reg1, reg2, ())));
+pub fn fmul64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x63, reg0, reg1, reg2)) }
 }
 /// Floating point division (32b)
-pub fn fdiv32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x64, reg0, reg1, reg2, ())));
+pub fn fdiv32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x64, reg0, reg1, reg2)) }
 }
 /// Floating point division (64b)
-pub fn fdiv64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x65, reg0, reg1, reg2, ())));
+pub fn fdiv64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x65, reg0, reg1, reg2)) }
 }
 /// Float fused multiply-add (32b)
-pub fn fma32(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x66, reg0, reg1, reg2, reg3)));
+pub fn fma32(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x66, reg0, reg1, reg2, reg3)) }
 }
 /// Float fused multiply-add (64b)
-pub fn fma64(&mut self, reg0: u8, reg1: u8, reg2: u8, reg3: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x67, reg0, reg1, reg2, reg3)));
+pub fn fma64(reg0: u8, reg1: u8, reg2: u8, reg3: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRRR(0x67, reg0, reg1, reg2, reg3)) }
 }
 /// Float reciprocal (32b)
-pub fn finv32(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x68, reg0, reg1, (), ())));
+pub fn finv32(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x68, reg0, reg1)) }
 }
 /// Float reciprocal (64b)
-pub fn finv64(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x69, reg0, reg1, (), ())));
+pub fn finv64(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x69, reg0, reg1)) }
 }
 /// Flaot compare less than (32b)
-pub fn fcmplt32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6A, reg0, reg1, reg2, ())));
+pub fn fcmplt32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x6A, reg0, reg1, reg2)) }
 }
 /// Flaot compare less than (64b)
-pub fn fcmplt64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6B, reg0, reg1, reg2, ())));
+pub fn fcmplt64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x6B, reg0, reg1, reg2)) }
 }
 /// Flaot compare greater than (32b)
-pub fn fcmpgt32(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6C, reg0, reg1, reg2, ())));
+pub fn fcmpgt32(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x6C, reg0, reg1, reg2)) }
 }
 /// Flaot compare greater than (64b)
-pub fn fcmpgt64(&mut self, reg0: u8, reg1: u8, reg2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6D, reg0, reg1, reg2, ())));
+pub fn fcmpgt64(reg0: u8, reg1: u8, reg2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRR(0x6D, reg0, reg1, reg2)) }
 }
 /// Int to 32 bit float
-pub fn itf32(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6E, reg0, reg1, (), ())));
+pub fn itf32(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x6E, reg0, reg1)) }
 }
 /// Int to 64 bit float
-pub fn itf64(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x6F, reg0, reg1, (), ())));
+pub fn itf64(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x6F, reg0, reg1)) }
 }
 /// Float 32 to int
-pub fn fti32(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x70, reg0, reg1, imm2, ())));
+pub fn fti32(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x70, reg0, reg1, imm2)) }
 }
 /// Float 64 to int
-pub fn fti64(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x71, reg0, reg1, imm2, ())));
+pub fn fti64(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x71, reg0, reg1, imm2)) }
 }
 /// Float 64 to Float 32
-pub fn fc32t64(&mut self, reg0: u8, reg1: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x72, reg0, reg1, (), ())));
+pub fn fc32t64(reg0: u8, reg1: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RR(0x72, reg0, reg1)) }
 }
 /// Float 32 to Float 64
-pub fn fc64t32(&mut self, reg0: u8, reg1: u8, imm2: u8) {
-    self.extend(crate::as_bytes(&crate::Args(0x73, reg0, reg1, imm2, ())));
+pub fn fc64t32(reg0: u8, reg1: u8, imm2: u8) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRB(0x73, reg0, reg1, imm2)) }
 }
 /// Load relative immediate (16 bit)
-pub fn lra16(&mut self, reg0: u8, reg1: u8, offset2: u32) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x74, reg0, reg1, 0u16, ())));
+pub fn lra16(reg0: u8, reg1: u8, offset2: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRP(0x74, reg0, reg1, offset2)) }
 }
 /// Load from relative address (16 bit)
-pub fn ldr16(&mut self, reg0: u8, reg1: u8, offset2: u32, imm3: u16) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x75, reg0, reg1, 0u16, imm3)));
+pub fn ldr16(reg0: u8, reg1: u8, offset2: i16, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRPH(0x75, reg0, reg1, offset2, imm3)) }
 }
 /// Store to relative address (16 bit)
-pub fn str16(&mut self, reg0: u8, reg1: u8, offset2: u32, imm3: u16) {
-    self.offset(offset2, 3, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x76, reg0, reg1, 0u16, imm3)));
+pub fn str16(reg0: u8, reg1: u8, offset2: i16, imm3: u16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(RRPH(0x76, reg0, reg1, offset2, imm3)) }
 }
 /// Relative jump (16 bit)
-pub fn jmp16(&mut self, offset0: u32) {
-    self.offset(offset0, 1, 2);
-    self.extend(crate::as_bytes(&crate::Args(0x77, 0u16, (), (), ())));
-}
+pub fn jmp16(offset0: i16) -> (usize, [u8; MAX_SIZE]) {
+    unsafe { crate::encode(P(0x77, offset0)) }
 }
+#[repr(packed)] pub struct N(u8, );
+#[repr(packed)] pub struct RRR(u8, u8, u8, u8);
+#[repr(packed)] pub struct RRRR(u8, u8, u8, u8, u8);
+#[repr(packed)] pub struct RR(u8, u8, u8);
+#[repr(packed)] pub struct RRB(u8, u8, u8, u8);
+#[repr(packed)] pub struct RRH(u8, u8, u8, u16);
+#[repr(packed)] pub struct RRW(u8, u8, u8, u32);
+#[repr(packed)] pub struct RRD(u8, u8, u8, u64);
+#[repr(packed)] pub struct RB(u8, u8, u8);
+#[repr(packed)] pub struct RH(u8, u8, u16);
+#[repr(packed)] pub struct RW(u8, u8, u32);
+#[repr(packed)] pub struct RD(u8, u8, u64);
+#[repr(packed)] pub struct RRO(u8, u8, u8, i32);
+#[repr(packed)] pub struct RRAH(u8, u8, u8, u64, u16);
+#[repr(packed)] pub struct RROH(u8, u8, u8, i32, u16);
+#[repr(packed)] pub struct O(u8, i32);
+#[repr(packed)] pub struct RRA(u8, u8, u8, u64);
+#[repr(packed)] pub struct RRP(u8, u8, u8, i16);
+#[repr(packed)] pub struct RRPH(u8, u8, u8, i16, u16);
+#[repr(packed)] pub struct P(u8, i16);
+pub const NAMES: [&str; 120] = [
+    "un",
+    "tx",
+    "nop",
+    "add8",
+    "add16",
+    "add32",
+    "add64",
+    "sub8",
+    "sub16",
+    "sub32",
+    "sub64",
+    "mul8",
+    "mul16",
+    "mul32",
+    "mul64",
+    "and",
+    "or",
+    "xor",
+    "slu8",
+    "slu16",
+    "slu32",
+    "slu64",
+    "sru8",
+    "sru16",
+    "sru32",
+    "sru64",
+    "srs8",
+    "srs16",
+    "srs32",
+    "srs64",
+    "cmpu",
+    "cmps",
+    "diru8",
+    "diru16",
+    "diru32",
+    "diru64",
+    "dirs8",
+    "dirs16",
+    "dirs32",
+    "dirs64",
+    "neg",
+    "not",
+    "sxt8",
+    "sxt16",
+    "sxt32",
+    "addi8",
+    "addi16",
+    "addi32",
+    "addi64",
+    "muli8",
+    "muli16",
+    "muli32",
+    "muli64",
+    "andi",
+    "ori",
+    "xori",
+    "slui8",
+    "slui16",
+    "slui32",
+    "slui64",
+    "srui8",
+    "srui16",
+    "srui32",
+    "srui64",
+    "srsi8",
+    "srsi16",
+    "srsi32",
+    "srsi64",
+    "cmpui",
+    "cmpsi",
+    "cp",
+    "swa",
+    "li8",
+    "li16",
+    "li32",
+    "li64",
+    "lra",
+    "ld",
+    "st",
+    "ldr",
+    "str",
+    "bmc",
+    "brc",
+    "jmp",
+    "jal",
+    "jala",
+    "jeq",
+    "jne",
+    "jltu",
+    "jgtu",
+    "jlts",
+    "jgts",
+    "eca",
+    "ebp",
+    "fadd32",
+    "fadd64",
+    "fsub32",
+    "fsub64",
+    "fmul32",
+    "fmul64",
+    "fdiv32",
+    "fdiv64",
+    "fma32",
+    "fma64",
+    "finv32",
+    "finv64",
+    "fcmplt32",
+    "fcmplt64",
+    "fcmpgt32",
+    "fcmpgt64",
+    "itf32",
+    "itf64",
+    "fti32",
+    "fti64",
+    "fc32t64",
+    "fc64t32",
+    "lra16",
+    "ldr16",
+    "str16",
+    "jmp16",
+];
diff --git a/hblang/src/lexer.rs b/hblang/src/lexer.rs
index 1de5aef..03153bf 100644
--- a/hblang/src/lexer.rs
+++ b/hblang/src/lexer.rs
@@ -22,6 +22,7 @@ pub enum TokenKind {
     LBrack,
     RBrack,
     Decl,
+    Assign,
     Plus,
     Minus,
     Star,
@@ -47,6 +48,7 @@ impl std::fmt::Display for TokenKind {
             T::LBrack => "[",
             T::RBrack => "]",
             T::Decl => ":=",
+            T::Assign => "=",
             T::Plus => "+",
             T::Minus => "-",
             T::Star => "*",
@@ -64,11 +66,12 @@ impl std::fmt::Display for TokenKind {
 
 impl TokenKind {
     pub fn precedence(&self) -> Option<u8> {
-        match self {
-            Self::Plus | Self::Minus => Some(2),
-            Self::Star | Self::FSlash => Some(3),
-            _ => None,
-        }
+        Some(match self {
+            Self::Assign => 1,
+            Self::Plus | Self::Minus => 2,
+            Self::Star | Self::FSlash => 3,
+            _ => return None,
+        })
     }
 }
 
@@ -162,6 +165,7 @@ impl<'a> Iterator for Lexer<'a> {
                     false => T::Colon,
                 },
                 b';' => T::Semi,
+                b'=' => T::Assign,
                 b'+' => T::Plus,
                 b'-' => T::Minus,
                 b'*' => T::Star,
diff --git a/hblang/src/lib.rs b/hblang/src/lib.rs
index d603026..51b21e8 100644
--- a/hblang/src/lib.rs
+++ b/hblang/src/lib.rs
@@ -22,12 +22,9 @@ mod parser;
 mod tests;
 mod typechk;
 
-#[repr(packed)]
-struct Args<A, B, C, D>(u8, A, B, C, D);
-fn as_bytes<T>(args: &T) -> &[u8] {
-    unsafe { core::slice::from_raw_parts(args as *const _ as *const u8, core::mem::size_of::<T>()) }
-}
-
-pub fn try_block<R>(f: impl FnOnce() -> R) -> R {
-    f()
+#[inline]
+unsafe fn encode<T>(instr: T) -> (usize, [u8; instrs::MAX_SIZE]) {
+    let mut buf = [0; instrs::MAX_SIZE];
+    std::ptr::write(buf.as_mut_ptr() as *mut T, instr);
+    (std::mem::size_of::<T>(), buf)
 }
diff --git a/hblang/src/parser.rs b/hblang/src/parser.rs
index b83fbd2..b20e31d 100644
--- a/hblang/src/parser.rs
+++ b/hblang/src/parser.rs
@@ -195,7 +195,7 @@ impl<'a> std::fmt::Display for Expr<'a> {
             Self::Block { stmts } => {
                 writeln!(f, "{{")?;
                 INDENT.with(|i| i.set(i.get() + 1));
-                let res = crate::try_block(|| {
+                let res = (|| {
                     for stmt in stmts {
                         for _ in 0..INDENT.with(|i| i.get()) {
                             write!(f, "    ")?;
@@ -203,7 +203,7 @@ impl<'a> std::fmt::Display for Expr<'a> {
                         writeln!(f, "{}", stmt)?;
                     }
                     Ok(())
-                });
+                })();
                 INDENT.with(|i| i.set(i.get() - 1));
                 write!(f, "}}")?;
                 res
diff --git a/hblang/tests/hblang::codegen::tests::variables.txt b/hblang/tests/hblang::codegen::tests::variables.txt
new file mode 100644
index 0000000..e69de29
diff --git a/hbvm/src/vmrun.rs b/hbvm/src/vmrun.rs
index c814151..4770188 100644
--- a/hbvm/src/vmrun.rs
+++ b/hbvm/src/vmrun.rs
@@ -173,7 +173,7 @@ where
                     LI64 => handler!(self, |OpsRD(tg, imm)| self.write_reg(tg, imm)),
                     LRA => handler!(self, |OpsRRO(tg, reg, off)| self.write_reg(
                         tg,
-                        self.pcrel(off, 3)
+                        self.pcrel(off)
                             .wrapping_add(self.read_reg(reg).cast::<i64>())
                             .get(),
                     )),
@@ -186,13 +186,13 @@ where
                     LDR => handler!(self, |OpsRROH(dst, base, off, count)| self.load(
                         dst,
                         base,
-                        self.pcrel(off, 3).get(),
+                        self.pcrel(off).get(),
                         count
                     )?),
                     STR => handler!(self, |OpsRROH(dst, base, off, count)| self.store(
                         dst,
                         base,
-                        self.pcrel(off, 3).get(),
+                        self.pcrel(off).get(),
                         count
                     )?),
                     BMC => {
@@ -252,7 +252,7 @@ where
 
                         self.write_reg(save, self.pc.next::<OpsRRO>());
                         self.pc = self
-                            .pcrel(offset, 3)
+                            .pcrel(offset)
                             .wrapping_add(self.read_reg(reg).cast::<i64>());
                     }
                     JALA => {
@@ -269,7 +269,7 @@ where
                     JNE => {
                         let OpsRRP(a0, a1, ja) = self.decode();
                         if self.read_reg(a0).cast::<u64>() != self.read_reg(a1).cast::<u64>() {
-                            self.pc = self.pcrel(ja, 3);
+                            self.pc = self.pcrel(ja);
                         } else {
                             self.bump_pc::<OpsRRP>();
                         }
@@ -346,18 +346,18 @@ where
                     LDR16 => handler!(self, |OpsRRPH(dst, base, off, count)| self.load(
                         dst,
                         base,
-                        self.pcrel(off, 3).get(),
+                        self.pcrel(off).get(),
                         count
                     )?),
                     STR16 => handler!(self, |OpsRRPH(dst, base, off, count)| self.store(
                         dst,
                         base,
-                        self.pcrel(off, 3).get(),
+                        self.pcrel(off).get(),
                         count
                     )?),
                     JMP16 => {
                         let OpsP(off) = self.decode();
-                        self.pc = self.pcrel(off, 1);
+                        self.pc = self.pcrel(off);
                     }
                     op => return Err(VmRunError::InvalidOpcode(op)),
                 }
@@ -532,8 +532,8 @@ where
 
     /// Calculate pc-relative address
     #[inline(always)]
-    fn pcrel(&self, offset: impl AddressOp, pos: u8) -> Address {
-        self.pc.wrapping_add(pos).wrapping_add(offset)
+    fn pcrel(&self, offset: impl AddressOp) -> Address {
+        self.pc.wrapping_add(offset)
     }
 
     /// Jump at `PC + #3` if ordering on `#0 <=> #1` is equal to expected
@@ -546,7 +546,7 @@ where
             .cmp(&self.read_reg(a1).cast::<T>())
             == expected
         {
-            self.pc = self.pcrel(ja, 3);
+            self.pc = self.pcrel(ja);
         } else {
             self.bump_pc::<OpsRRP>();
         }