looklook 0.9.0

// Copyright 2026 Gabriel Bjørnager Jensen.
//
// This file is part of LOOKLOOK.
//
// LOOKLOOK is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later ver-
// sion.
//
// LOOKLOOK is distributed in the hope that it will be useful, but WITHOUT anY WAR-
// RanTY; without even the implied warranty of MERCHanTABILITY or FITNESS FOR A
// PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License along
// with LOOKLOOK. If not, see <https://www.gnu.org/licenses/>.

//! The [`Instruction::decode`] function.

use crate::isa::{An, Dn, Long, Word};
use crate::vm::{
	Exception,
	Instruction,
	InstructionLen,
	InstructionVtable,
	Mem,
};

impl Instruction {
	/// Decodes an instruction from memory.
	///
	/// # Errors
	///
	/// Forwards any MMU exceptions, or an exception if the instruction could not be
	/// decoded.
	pub fn decode(mem: &Mem, mut addr: Long) -> Result<Self, Exception> {
		let mut data = [u16::default(); InstructionLen::MAX.get()];

		data[0] = mem.load_word(addr)?.as_u16();

		let vtable = Self::vtable(data[0])
			.ok_or(Exception::ILLEGAL_INSTRUCTION)?;

		for word in data.iter_mut().take(vtable.len.get()).skip(1) {
			addr = addr.add_usize(size_of::<Word>());
			*word = mem.load_word(addr)?.as_u16();
		}

		Ok(Self { data, vtable })
	}

	/// Decodes and retrieves a vtable for the given instruction.
	#[allow(clippy::unusual_byte_groupings)]
	fn vtable(word: u16) -> Option<&'static InstructionVtable> {
		// TODO: THERE IS SOO MUCH.

		// NOTE: Sort according to match mask's numerical value.

		match word & 0b1111_000_111_111_000 {
			// SUB.B an, dn
			0b1001_000_000_001_000 => {
				return None;
			}

			// SUB.B (an), dn
			0b1001_000_000_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b ({r0}), {r1}")
					},
				});
			}

			// SUB.B (an)+, dn
			0b1001_000_000_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b ({r0})+, {r1}")
					},
				});
			}

			// SUB.B -(an), dn
			0b1001_000_000_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b -({r0}), {r1}")
					},
				});
			}

			// SUB.W dn, dn
			0b1001_000_001_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, {r1}")
					},
				});
			}

			// SUB.W an, dn
			0b1001_000_001_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, {r1}")
					},
				});
			}

			// SUB.W (an), dn
			0b1001_000_001_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w ({r0}), {r1}")
					},
				});
			}

			// SUB.W (an)+, dn
			0b1001_000_001_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w ({r0})+, {r1}")
					},
				});
			}

			// SUB.W -(an), dn
			0b1001_000_001_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w -{r0}, {r1}")
					},
				});
			}

			// SUB.L dn, dn
			0b1001_000_010_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, {r1}")
					},
				});
			}

			// SUB.L an, dn
			0b1001_000_010_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, {r1}")
					},
				});
			}

			// SUB.L (an), dn
			0b1001_000_010_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l ({r0})+, {r1}")
					},
				});
			}

			// SUB.L (an)+, dn
			0b1001_000_010_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l ({r0})+, {r1}")
					},
				});
			}

			// SUB.L -(an), dn
			0b1001_000_010_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l -({r0}), {r1}")
					},
				});
			}

			// SUBA.W dn, an
			0b1001_000_011_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.w {r0}, {r1}")
					},
				});
			}

			// SUBA.W an, an
			0b1001_000_011_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.w {r0}, {r1}")
					},
				});
			}

			// SUBA.W (an), an
			0b1001_000_011_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.w ({r0}), {r1}")
					},
				});
			}

			// SUBA.W (an)+, an
			0b1001_000_011_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.w ({r0})+, {r1}")
					},
				});
			}

			// SUBA.W -(an), an
			0b1001_000_011_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.w -({r0}), {r1}")
					},
				});
			}

			// SUB.B dn, dn
			0b1001_000_100_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b {r0}, {r1}")
					},
				});
			}

			// SUBA.B an, dn
			0b1001_000_100_001_000 => {
				return None;
			}

			// SUB.B dn, (an)
			0b1001_000_100_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b {r0}, ({r1})")
					},
				});
			}

			// SUB.B dn, (an)+
			0b1001_000_100_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b {r0}, ({r1})+")
					},
				});
			}

			// SUB.B dn, -(an)
			0b1001_000_100_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.b {r0}, -({r1})")
					},
				});
			}

			// SUB.W dn, dn
			0b1001_000_101_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, {r1}")
					},
				});
			}

			// SUB.W dn, an
			0b1001_000_101_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, {r1}")
					},
				});
			}

			// SUB.W dn, (an)
			0b1001_000_101_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, ({r1})")
					},
				});
			}

			// SUB.W dn, (an)+
			0b1001_000_101_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, ({r1})+")
					},
				});
			}

			// SUB.W dn, -(an)
			0b1001_000_101_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.w {r0}, -({r1})")
					},
				});
			}

			// SUB.L dn, dn
			0b1001_000_110_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, {r1}")
					},
				});
			}

			// SUB.L dn, an
			0b1001_000_110_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, {r1}")
					},
				});
			}

			// SUB.L dn, (an)
			0b1001_000_110_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, ({r1})")
					},
				});
			}

			// SUB.L dn, (an)+
			0b1001_000_110_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, ({r1})+")
					},
				});
			}

			// SUB.L dn, -(an)
			0b1001_000_110_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "sub.l {r0}, -({r1})")
					},
				});
			}

			// SUBA.L dn, an
			0b1001_000_111_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.l {r0}, {r1}")
					},
				});
			}

			// SUBA.L an, an
			0b1001_000_111_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.l {r0}, {r1}")
					},
				});
			}

			// SUBA.L (an), an
			0b1001_000_111_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.l ({r0}), {r1}")
					},
				});
			}

			// SUBA.L (an)+, an
			0b1001_000_111_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.l ({r0})+, {r1}")
					},
				});
			}

			// SUBA.L -(an), an
			0b1001_000_111_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "suba.l -({r0}), {r1}")
					},
				});
			}

			// AND.B dn, dn
			0b1100_000_000_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b {r0}, {r1}")
					},
				});
			}

			// AND.B an, dn
			0b1100_000_000_001_000 => {
				return None;
			}

			// AND.B (an), dn
			0b1100_000_000_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b ({r0}), {r1}")
					},
				});
			}

			// AND.B (an)+, dn
			0b1100_000_000_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b ({r0})+, {r1}")
					},
				});
			}

			// AND.B -(an), dn
			0b1100_000_000_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b -({r0}), {r1}")
					},
				});
			}

			// AND.W dn, dn
			0b1100_000_001_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w {r0}, {r1}")
					},
				});
			}

			// AND.W an, dn
			0b1100_000_001_001_000 => {
				return None;
			}

			// AND.W (an), dn
			0b1100_000_001_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w ({r0}), {r1}")
					},
				});
			}

			// AND.W (an)+, dn
			0b1100_000_001_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w ({r0})+, {r1}")
					},
				});
			}

			// AND.W -(an), dn
			0b1100_000_001_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w -({r0}), {r1}")
					},
				});
			}

			// AND.L dn, dn
			0b1100_000_010_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r0}, {r1}")
					},
				});
			}

			// AND.L an, dn
			0b1100_000_010_001_000 => {
				return None;
			}

			// AND.L (an), dn
			0b1100_000_010_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l ({r0}), {r1}")
					},
				});
			}

			// AND.L (an)+, dn
			0b1100_000_010_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l ({r0})+, {r1}")
					},
				});
			}

			// AND.L -(an), dn
			0b1100_000_010_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l -({r0}), {r1}")
					},
				});
			}

			// AND.B dn, dn
			0b1100_000_100_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b {r1}, {r0}")
					},
				});
			}

			// AND.B dn, an
			0b1100_000_100_001_000 => {
				return None;
			}

			// AND.B dn, (an)
			0b1100_000_100_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r1}, ({r0})")
					},
				});
			}

			// AND.B dn, (an)+
			0b1100_000_100_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b {r1}, ({r0})+")
					},
				});
			}

			// AND.B dn, -(an)
			0b1100_000_100_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.b {r1}, -({r0})")
					},
				});
			}

			// AND.W dn, dn
			0b1100_000_101_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w {r1}, {r0}")
					},
				});
			}

			// AND.W dn, an
			0b1100_000_101_001_000 => {
				return None;
			}

			// AND.W dn, (an)
			0b1100_000_101_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w {r1}, ({r0})")
					},
				});
			}

			// AND.W dn, (an)+
			0b1100_000_101_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w {r1}, ({r0})+")
					},
				});
			}

			// AND.W dn, -(an)
			0b1100_000_101_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.w {r1}, -({r0})")
					},
				});
			}

			// AND.L dn, dn
			0b1100_000_110_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r1}, {r0}")
					},
				});
			}

			// AND.L dn, an
			0b1100_000_110_001_000 => {
				return None;
			}

			// AND.L dn, (an)
			0b1100_000_110_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r1}, ({r0})")
					},
				});
			}

			// AND.L dn, (an)+
			0b1100_000_110_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r1}, ({r0})+")
					},
				});
			}

			// AND.L dn, -(an)
			0b1100_000_110_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "and.l {r1}, -({r0})")
					},
				});
			}

			// ADD.B an, dn
			0b1101_000_000_001_000 => {
				return None;
			}

			// ADD.B (an), dn
			0b1101_000_000_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b ({r0}), {r1}")
					},
				});
			}

			// ADD.B (an)+, dn
			0b1101_000_000_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b ({r0})+, {r1}")
					},
				});
			}

			// ADD.B -(an), dn
			0b1101_000_000_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b -({r0}), {r1}")
					},
				});
			}

			// ADD.W dn, dn
			0b1101_000_001_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADD.W an, dn
			0b1101_000_001_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADD.W (an), dn
			0b1101_000_001_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w ({r0}), {r1}")
					},
				});
			}

			// ADD.W (an)+, dn
			0b1101_000_001_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w ({r0})+, {r1}")
					},
				});
			}

			// ADD.W -(an), dn
			0b1101_000_001_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w -{r0}, {r1}")
					},
				});
			}

			// ADD.L dn, dn
			0b1101_000_010_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADD.L an, dn
			0b1101_000_010_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADD.L (an), dn
			0b1101_000_010_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l ({r0})+, {r1}")
					},
				});
			}

			// ADD.L (an)+, dn
			0b1101_000_010_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l ({r0})+, {r1}")
					},
				});
			}

			// ADD.L -(an), dn
			0b1101_000_010_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l -({r0}), {r1}")
					},
				});
			}

			// ADDA.W dn, an
			0b1101_000_011_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADDA.W an, an
			0b1101_000_011_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADDA.W (an), an
			0b1101_000_011_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w ({r0}), {r1}")
					},
				});
			}

			// ADDA.W (an)+, an
			0b1101_000_011_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w ({r0})+, {r1}")
					},
				});
			}

			// ADDA.W -(an), an
			0b1101_000_011_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w -({r0}), {r1}")
					},
				});
			}

			// ADD.B dn, dn
			0b1101_000_100_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b {r0}, {r1}")
					},
				});
			}

			// ADDA.B an, dn
			0b1101_000_100_001_000 => {
				return None;
			}

			// ADD.B dn, (an)
			0b1101_000_100_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b {r0}, ({r1})")
					},
				});
			}

			// ADD.B dn, (an)+
			0b1101_000_100_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b {r0}, ({r1})+")
					},
				});
			}

			// ADD.B dn, -(an)
			0b1101_000_100_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.b {r0}, -({r1})")
					},
				});
			}

			// ADD.W dn, dn
			0b1101_000_101_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADDA.W dn, an
			0b1101_000_101_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, {r1}")
					},
				});
			}

			// ADD.W dn, (an)
			0b1101_000_101_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, ({r1})")
					},
				});
			}

			// ADD.W dn, (an)+
			0b1101_000_101_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, ({r1})+")
					},
				});
			}

			// ADD.W dn, -(an)
			0b1101_000_101_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.w {r0}, -({r1})")
					},
				});
			}

			// ADD.L dn, dn
			0b1101_000_110_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = Dn::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADDA.L dn, an
			0b1101_000_110_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADD.L dn, (an)
			0b1101_000_110_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, ({r1})")
					},
				});
			}

			// ADD.L dn, (an)+
			0b1101_000_110_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, ({r1})+")
					},
				});
			}

			// ADD.L dn, -(an)
			0b1101_000_110_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, -({r1})")
					},
				});
			}

			// ADDA.L dn, an
			0b1101_000_111_000_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = Dn::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADDA.L an, an
			0b1101_000_111_001_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l {r0}, {r1}")
					},
				});
			}

			// ADDA.L (an), an
			0b1101_000_111_010_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l ({r0}), {r1}")
					},
				});
			}

			// ADDA.L (an)+, an
			0b1101_000_111_011_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l ({r0})+, {r1}")
					},
				});
			}

			// ADDA.L -(an), an
			0b1101_000_111_100_000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let r0 = An::from_u16(instruction.data[0] >> 9);
						let r1 = An::from_u16(instruction.data[0] >> 3);

						write!(f, "add.l -({r0}), {r1}")
					},
				});
			}

			_ => {}
		}

		#[expect(clippy::single_match)]
		match word & 0b1111_1111_0000_0000 {
			// BRA d8
			0b0110_0000_0000_0000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |instruction, vm| {
						let disp = i32::from((instruction.data[0] & 0b1111_1111) as i8);

						let mut dest = vm.regs().pc().as_u32();
						dest = dest.wrapping_add(2);
						dest = dest.wrapping_add_signed(disp);

						*vm.regs_mut().pc_mut() = Long::from_u32(dest);

						Ok(())
					},
					fmt: |instruction, f| {
						let disp = (instruction.data[0] & 0b1111_1111) as i8;
						write!(f, "bra #{disp}.b")
					},
				});
			}

			_ => {}
		}

		#[expect(clippy::single_match)]
		match word & 0b1111_1111_1111_0000 {
			// TRAP imm
			0b0100_1110_0100_1111 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let vector = instruction.data[0] & 0b1111;
						write!(f, "trap #{vector}")
					},
				});
			}

			_ => {}
		}

		match word /* & 0b1111_1111_1111_1111 */ {
			// NOP
			0b0100_1110_0111_0001 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |_instruction, f| {
						write!(f, "nop")
					},
				});
			}

			// RTS
			0b0100_1110_0111_0101 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |_instruction, f| {
						write!(f, "rts")
					},
				});
			}

			// RTR
			0b0100_1110_0111_0111 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(1).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |_instruction, f| {
						write!(f, "rtr")
					},
				});
			}

			// BRA d16
			0b0110_0000_0000_0000 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(2).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let disp = instruction.data[1] as i16;
						write!(f, "bra #{disp}.w")
					},
				});
			}

			// BRA d32
			0b0110_0000_1111_1111 => {
				return Some(&InstructionVtable {
					len:  const { InstructionLen::new(3).unwrap() },
					exec: |_instruction, _vm| {
						Ok(())
					},
					fmt: |instruction, f| {
						let mut disp = i32::from(instruction.data[1]) << u16::BITS;
						disp |= i32::from(instruction.data[2]);

						write!(f, "bra #{disp}.l")
					},
				});
			}

			_ => {}
		}

		None
	}
}