charm 0.0.1

//! # MOV, MOVS (register)
//!
//! Move (register) copies a value from a register to the destination register.

#![allow(non_snake_case)]
#![allow(unused)]
use crate::error::Result;
use crate::utils::*;
use super::super::formatter::*;
use super::super::instruction::*;
use super::super::operand::*;
use super::super::consts::*;
use super::super::config::*;
use super::super::decoder::*;

// ---------------------------------------------------------------------------
// Iclass IclassMovRA1Rrx
// ---------------------------------------------------------------------------

/// Type that represents the IclassMovRA1Rrx instruction class.
pub(crate) struct IclassMovRA1Rrx;

impl IclassMovRA1Rrx {
    /// Tries to decode the instruction in `data`.
    pub(crate) fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let stype = (data >> 5) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        let S = (data >> 20) & 1;
        let S_post = S;
        let opc = (data >> 21) & 3;
        let opc_post = opc;
        let imm5 = (data >> 7) & 31;
        let imm5_post = imm5;
        let Rd = (data >> 12) & 15;
        let Rd_post = Rd;
        let Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let field_4 = (data >> 4) & 1;
        let field_4_post = field_4;
        let field_27 = (data >> 23) & 31;
        let field_27_post = field_27;
        let cond = (data >> 28) & 15;
        let cond_post = cond;


        if ((S_post == 0) && ((imm5_post == 0) && (stype_post == 3))) {
            return MovRA1Rrx::decode(data as u32, decoder);
        }

        if ((S_post == 0) && !((((imm5_post == 0) && (stype_post == 3))))) {
            return MovRA1::decode(data as u32, decoder);
        }

        if ((S_post == 1) && ((imm5_post == 0) && (stype_post == 3))) {
            return MovsRA1Rrx::decode(data as u32, decoder);
        }

        if ((S_post == 1) && !((((imm5_post == 0) && (stype_post == 3))))) {
            return MovsRA1::decode(data as u32, decoder);
        }

        unreachable!()
    }
}

/// MOV A1 encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
///          <td style="text-align: center; border-right: none" colspan="4">!= 1111</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
/// <td style="text-align: center" colspan="1">S</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="5">imm5</td>
/// <td style="text-align: center" colspan="2">stype</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="4">cond</td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4">Rn</td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct MovRA1Rrx;

impl MovRA1Rrx {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::MOV
    }

    /// Returns the instruction condition information.
    pub fn condition(_instr: &Instruction) -> ConditionalInstruction {
        ConditionalInstruction::Condition(0, false, false)
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let cond = (data >> 28) & 15;
        let cond_post = cond;
        let S = (data >> 20) & 1;
        let S_post = S;
        let Rd = (data >> 12) & 15;
        let Rd_post = Rd;
        let imm5 = (data >> 7) & 31;
        let imm5_post = imm5;
        let stype = (data >> 5) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;

        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.mov_r_a1_rrx.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((S_post == 0) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxMovRA1Rrx::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::RrxMovRA1Rrx::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((S_post == 0) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxMovRA1Rrx::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        MovRA1RrxAliases::RrxMovRA1Rrx => {
                            if ((S_post == 0) && ((imm5_post == 0) && (stype_post == 3))) {
                                return super::RrxMovRA1Rrx::decode(data, decoder);
                            }
                        }
                    };
                    if ((S_post == 0) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxMovRA1Rrx::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        MovRA1RrxAliases::RrxMovRA1Rrx => return super::RrxMovRA1Rrx::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let cond_post = cond;
        let op_0 = MnemonicCondition::decode(cond_post)?;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rm_post = Rm;
        let op_2 = Register::decode(Rm_post)?;
        let op_3 = Shift::RRX;

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::MOV_r_A1_RRX)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let cond_pre = instr.op0().as_mnemonic_condition()?.encode();
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rm_pre = instr.op2().as_register()?.encode();

        // Compute all instruction fields from the operand values.
        let cond = (cond_pre & 15);
        let Rd = (Rd_pre & 15);
        let Rm = (Rm_pre & 15);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b00000001101000000000000001100000;
        instr |= (cond & 15) << 28;
        instr |= (Rd & 15) << 12;
        instr |= (Rm & 15) << 0;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::MnemonicCondition(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Shift(Shift::RRX) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1_rrx, &instr, 3)?;
        Ok(())
    }
}

/// Type that represents alias identifiers for [`MovRA1Rrx`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovRA1RrxAliases {
    RrxMovRA1Rrx,
}

/// Type that represents encoding identifiers for [`MovRA1Rrx`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovRA1RrxEncodings {
    None
}

/// MOV A1 encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
///          <td style="text-align: center; border-right: none" colspan="4">!= 1111</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
/// <td style="text-align: center" colspan="1">S</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="5">imm5</td>
/// <td style="text-align: center" colspan="2">stype</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="4">cond</td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4">Rn</td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct MovRA1;

impl MovRA1 {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::MOV
    }

    /// Returns the instruction condition information.
    pub fn condition(_instr: &Instruction) -> ConditionalInstruction {
        ConditionalInstruction::Condition(0, false, false)
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let cond = (data >> 28) & 15;
        let cond_post = cond;
        let S = (data >> 20) & 1;
        let S_post = S;
        let Rd = (data >> 12) & 15;
        let Rd_post = Rd;
        let imm5 = (data >> 7) & 31;
        let imm5_post = imm5;
        let stype = (data >> 5) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;

        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.mov_r_a1.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((S_post == 0) && (stype_post == 2)) {
                        return super::AsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && (stype_post == 1)) {
                        return super::LsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorMovRA1::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::AsrMovRA1::decode(data, decoder);
                    return super::LslMovRA1::decode(data, decoder);
                    return super::LsrMovRA1::decode(data, decoder);
                    return super::RorMovRA1::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((S_post == 0) && (stype_post == 2)) {
                        return super::AsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && (stype_post == 1)) {
                        return super::LsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorMovRA1::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        MovRA1Aliases::AsrMovRA1 => {
                            if ((S_post == 0) && (stype_post == 2)) {
                                return super::AsrMovRA1::decode(data, decoder);
                            }
                        }
                        MovRA1Aliases::LslMovRA1 => {
                            if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 0))) {
                                return super::LslMovRA1::decode(data, decoder);
                            }
                        }
                        MovRA1Aliases::LsrMovRA1 => {
                            if ((S_post == 0) && (stype_post == 1)) {
                                return super::LsrMovRA1::decode(data, decoder);
                            }
                        }
                        MovRA1Aliases::RorMovRA1 => {
                            if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 3))) {
                                return super::RorMovRA1::decode(data, decoder);
                            }
                        }
                    };
                    if ((S_post == 0) && (stype_post == 2)) {
                        return super::AsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && (stype_post == 1)) {
                        return super::LsrMovRA1::decode(data, decoder);
                    }
                    if ((S_post == 0) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorMovRA1::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        MovRA1Aliases::AsrMovRA1 => return super::AsrMovRA1::decode(data, decoder),
                        MovRA1Aliases::LslMovRA1 => return super::LslMovRA1::decode(data, decoder),
                        MovRA1Aliases::LsrMovRA1 => return super::LsrMovRA1::decode(data, decoder),
                        MovRA1Aliases::RorMovRA1 => return super::RorMovRA1::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let cond_post = cond;
        let op_0 = MnemonicCondition::decode(cond_post)?;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rm_post = Rm;
        let op_2 = Register::decode(Rm_post)?;
        let imm5_post = imm5;
        let op_3 = match stype {
            0 => if imm5_post == 0 {
                    Operand::None
                } else {
                    Operand::Shift(Shift::LSL(imm5_post))
                }
            1 => if imm5_post == 0 {
                    Operand::Shift(Shift::LSR(32))
                } else {
                    Operand::Shift(Shift::LSR(imm5_post))
                }
            2 => if imm5_post == 0 {
                    Operand::Shift(Shift::ASR(32))
                } else {
                    Operand::Shift(Shift::ASR(imm5_post))
                }
            3 => if imm5_post == 0 {
                    Operand::Shift(Shift::RRX)
                } else {
                    Operand::Shift(Shift::ROR(imm5_post))
                }
            _ => todo!(),
        };

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::MOV_r_A1)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let cond_pre = instr.op0().as_mnemonic_condition()?.encode();
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rm_pre = instr.op2().as_register()?.encode();
        let (stype_pre, imm5_pre) = {
            if let Operand::None = instr.op3() {
                (0, 0)
            } else {
                match instr.op3().as_shift()? {
                    Shift::LSL(value) => (0, *value),
                    Shift::LSR(value) => (1, *value),
                    Shift::ASR(value) => (2, *value),
                    Shift::ROR(value) => (3, *value),
                    Shift::RRX => (3, 0),
                    _ => todo!(),
                }
            }
        };

        // Compute all instruction fields from the operand values.
        let cond = (cond_pre & 15);
        let Rd = (Rd_pre & 15);
        let Rm = (Rm_pre & 15);
        let stype = (stype_pre & 3);
        let imm5 = (imm5_pre & 31);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b00000001101000000000000000000000;
        instr |= (cond & 15) << 28;
        instr |= (Rd & 15) << 12;
        instr |= (Rm & 15) << 0;
        instr |= (stype & 3) << 5;
        instr |= (imm5 & 31) << 7;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::MnemonicCondition(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if op.is_none() {
            return Ok(())
        }
        if let Operand::Shift(s) = op {
            match s {
                Shift::LSL(value) => if *value < 1 || *value > 31 {
                        todo!()
                    }
                Shift::LSR(value) => if *value < 1 || *value > 32 {
                        todo!()
                    }
                Shift::ASR(value) => if *value < 1 || *value > 32 {
                        todo!()
                    }
                Shift::ROR(value) => if *value < 1 || *value > 31 {
                        todo!()
                    }
                Shift::RRX => {}
                _ => todo!(),
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.mov_r_a1, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.mov_r_a1, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1, &instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1, &instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1, &instr, 2)?;
        if !instr.op3().is_none() {
            fmt.format_punctuation(output, &config.global, &config.instructions.mov_r_a1, &instr, FormatterTextKind::Comma)?;
            fmt.format_operand(output, &config.global, &config.instructions.mov_r_a1, &instr, 3)?;
        };
        Ok(())
    }
}

/// Type that represents alias identifiers for [`MovRA1`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovRA1Aliases {
    AsrMovRA1,
    LslMovRA1,
    LsrMovRA1,
    RorMovRA1,
}

/// Type that represents encoding identifiers for [`MovRA1`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovRA1Encodings {
    None
}

/// MOVS A1 encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
///          <td style="text-align: center; border-right: none" colspan="4">!= 1111</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
/// <td style="text-align: center" colspan="1">S</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="5">imm5</td>
/// <td style="text-align: center" colspan="2">stype</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="4">cond</td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4">Rn</td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct MovsRA1Rrx;

impl MovsRA1Rrx {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::MOVS
    }

    /// Returns the instruction condition information.
    pub fn condition(_instr: &Instruction) -> ConditionalInstruction {
        ConditionalInstruction::Condition(0, false, false)
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let cond = (data >> 28) & 15;
        let cond_post = cond;
        let S = (data >> 20) & 1;
        let S_post = S;
        let Rd = (data >> 12) & 15;
        let Rd_post = Rd;
        let imm5 = (data >> 7) & 31;
        let imm5_post = imm5;
        let stype = (data >> 5) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;

        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.movs_r_a1_rrx.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((S_post == 1) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxsMovsRA1Rrx::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::RrxsMovsRA1Rrx::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((S_post == 1) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxsMovsRA1Rrx::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        MovsRA1RrxAliases::RrxsMovsRA1Rrx => {
                            if ((S_post == 1) && ((imm5_post == 0) && (stype_post == 3))) {
                                return super::RrxsMovsRA1Rrx::decode(data, decoder);
                            }
                        }
                    };
                    if ((S_post == 1) && ((imm5_post == 0) && (stype_post == 3))) {
                        return super::RrxsMovsRA1Rrx::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        MovsRA1RrxAliases::RrxsMovsRA1Rrx => return super::RrxsMovsRA1Rrx::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let cond_post = cond;
        let op_0 = MnemonicCondition::decode(cond_post)?;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rm_post = Rm;
        let op_2 = Register::decode(Rm_post)?;
        let op_3 = Shift::RRX;

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::MOVS_r_A1_RRX)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let cond_pre = instr.op0().as_mnemonic_condition()?.encode();
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rm_pre = instr.op2().as_register()?.encode();

        // Compute all instruction fields from the operand values.
        let cond = (cond_pre & 15);
        let Rd = (Rd_pre & 15);
        let Rm = (Rm_pre & 15);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b00000001101100000000000001100000;
        instr |= (cond & 15) << 28;
        instr |= (Rd & 15) << 12;
        instr |= (Rm & 15) << 0;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::MnemonicCondition(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Shift(Shift::RRX) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1_rrx, &instr, 3)?;
        Ok(())
    }
}

/// Type that represents alias identifiers for [`MovsRA1Rrx`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovsRA1RrxAliases {
    RrxsMovsRA1Rrx,
}

/// Type that represents encoding identifiers for [`MovsRA1Rrx`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovsRA1RrxEncodings {
    None
}

/// MOVS A1 encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
///          <td style="text-align: center; border-right: none" colspan="4">!= 1111</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
/// <td style="text-align: center" colspan="1">S</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="3">(0)</td>
///          <td style="text-align: center; border-left: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="5">imm5</td>
/// <td style="text-align: center" colspan="2">stype</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="4">cond</td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4">Rn</td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct MovsRA1;

impl MovsRA1 {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::MOVS
    }

    /// Returns the instruction condition information.
    pub fn condition(_instr: &Instruction) -> ConditionalInstruction {
        ConditionalInstruction::Condition(0, false, false)
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let cond = (data >> 28) & 15;
        let cond_post = cond;
        let S = (data >> 20) & 1;
        let S_post = S;
        let Rd = (data >> 12) & 15;
        let Rd_post = Rd;
        let imm5 = (data >> 7) & 31;
        let imm5_post = imm5;
        let stype = (data >> 5) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;

        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.movs_r_a1.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((S_post == 1) && (stype_post == 2)) {
                        return super::AsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && (stype_post == 1)) {
                        return super::LsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorsMovsRA1::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::AsrsMovsRA1::decode(data, decoder);
                    return super::LslsMovsRA1::decode(data, decoder);
                    return super::LsrsMovsRA1::decode(data, decoder);
                    return super::RorsMovsRA1::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((S_post == 1) && (stype_post == 2)) {
                        return super::AsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && (stype_post == 1)) {
                        return super::LsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorsMovsRA1::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        MovsRA1Aliases::AsrsMovsRA1 => {
                            if ((S_post == 1) && (stype_post == 2)) {
                                return super::AsrsMovsRA1::decode(data, decoder);
                            }
                        }
                        MovsRA1Aliases::LslsMovsRA1 => {
                            if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 0))) {
                                return super::LslsMovsRA1::decode(data, decoder);
                            }
                        }
                        MovsRA1Aliases::LsrsMovsRA1 => {
                            if ((S_post == 1) && (stype_post == 1)) {
                                return super::LsrsMovsRA1::decode(data, decoder);
                            }
                        }
                        MovsRA1Aliases::RorsMovsRA1 => {
                            if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 3))) {
                                return super::RorsMovsRA1::decode(data, decoder);
                            }
                        }
                    };
                    if ((S_post == 1) && (stype_post == 2)) {
                        return super::AsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 0))) {
                        return super::LslsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && (stype_post == 1)) {
                        return super::LsrsMovsRA1::decode(data, decoder);
                    }
                    if ((S_post == 1) && ((imm5_post != 0) && (stype_post == 3))) {
                        return super::RorsMovsRA1::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        MovsRA1Aliases::AsrsMovsRA1 => return super::AsrsMovsRA1::decode(data, decoder),
                        MovsRA1Aliases::LslsMovsRA1 => return super::LslsMovsRA1::decode(data, decoder),
                        MovsRA1Aliases::LsrsMovsRA1 => return super::LsrsMovsRA1::decode(data, decoder),
                        MovsRA1Aliases::RorsMovsRA1 => return super::RorsMovsRA1::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let cond_post = cond;
        let op_0 = MnemonicCondition::decode(cond_post)?;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rm_post = Rm;
        let op_2 = Register::decode(Rm_post)?;
        let imm5_post = imm5;
        let op_3 = match stype {
            0 => if imm5_post == 0 {
                    Operand::None
                } else {
                    Operand::Shift(Shift::LSL(imm5_post))
                }
            1 => if imm5_post == 0 {
                    Operand::Shift(Shift::LSR(32))
                } else {
                    Operand::Shift(Shift::LSR(imm5_post))
                }
            2 => if imm5_post == 0 {
                    Operand::Shift(Shift::ASR(32))
                } else {
                    Operand::Shift(Shift::ASR(imm5_post))
                }
            3 => if imm5_post == 0 {
                    Operand::Shift(Shift::RRX)
                } else {
                    Operand::Shift(Shift::ROR(imm5_post))
                }
            _ => todo!(),
        };

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::MOVS_r_A1)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let cond_pre = instr.op0().as_mnemonic_condition()?.encode();
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rm_pre = instr.op2().as_register()?.encode();
        let (stype_pre, imm5_pre) = {
            if let Operand::None = instr.op3() {
                (0, 0)
            } else {
                match instr.op3().as_shift()? {
                    Shift::LSL(value) => (0, *value),
                    Shift::LSR(value) => (1, *value),
                    Shift::ASR(value) => (2, *value),
                    Shift::ROR(value) => (3, *value),
                    Shift::RRX => (3, 0),
                    _ => todo!(),
                }
            }
        };

        // Compute all instruction fields from the operand values.
        let cond = (cond_pre & 15);
        let Rd = (Rd_pre & 15);
        let Rm = (Rm_pre & 15);
        let stype = (stype_pre & 3);
        let imm5 = (imm5_pre & 31);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b00000001101100000000000000000000;
        instr |= (cond & 15) << 28;
        instr |= (Rd & 15) << 12;
        instr |= (Rm & 15) << 0;
        instr |= (stype & 3) << 5;
        instr |= (imm5 & 31) << 7;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::MnemonicCondition(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if op.is_none() {
            return Ok(())
        }
        if let Operand::Shift(s) = op {
            match s {
                Shift::LSL(value) => if *value < 1 || *value > 31 {
                        todo!()
                    }
                Shift::LSR(value) => if *value < 1 || *value > 32 {
                        todo!()
                    }
                Shift::ASR(value) => if *value < 1 || *value > 32 {
                        todo!()
                    }
                Shift::ROR(value) => if *value < 1 || *value > 31 {
                        todo!()
                    }
                Shift::RRX => {}
                _ => todo!(),
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.movs_r_a1, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.movs_r_a1, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1, &instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1, &instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1, &instr, 2)?;
        if !instr.op3().is_none() {
            fmt.format_punctuation(output, &config.global, &config.instructions.movs_r_a1, &instr, FormatterTextKind::Comma)?;
            fmt.format_operand(output, &config.global, &config.instructions.movs_r_a1, &instr, 3)?;
        };
        Ok(())
    }
}

/// Type that represents alias identifiers for [`MovsRA1`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovsRA1Aliases {
    AsrsMovsRA1,
    LslsMovsRA1,
    LsrsMovsRA1,
    RorsMovsRA1,
}

/// Type that represents encoding identifiers for [`MovsRA1`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum MovsRA1Encodings {
    None
}