charm 0.0.1

//! # AND, ANDS (register)
//!
//! Bitwise AND (register) performs a bitwise AND of a register value and an optionally-shifted register value, and writes the result 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 IclassAndRT1
// ---------------------------------------------------------------------------

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

impl IclassAndRT1 {
    /// Tries to decode the instruction in `data`.
    pub(crate) fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let Rm = (data >> 3) & 7;
        let Rm_post = Rm;
        let op = (data >> 6) & 15;
        let op_post = op;
        let field_15 = (data >> 10) & 63;
        let field_15_post = field_15;
        let Rdn = (data >> 0) & 7;
        let Rdn_post = Rdn;


        return AndRT1::decode(data as u32, decoder);

        unreachable!()
    }
}

/// AND T1 encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <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="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; 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" colspan="1">0</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" colspan="1">0</td>
/// <td style="text-align: center" colspan="3">Rm</td>
/// <td style="text-align: center" colspan="3">Rdn</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="4">op</td>
/// <td style="text-align: center; border: none" colspan="3"></td>
/// <td style="text-align: center; border: none" colspan="3"></td>
///     </tr>
/// </table>
pub struct AndRT1;

impl AndRT1 {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(instr: &Instruction) -> Mnemonic {
        match instr.encoding {
            Encoding::Alt1 => Mnemonic::AND,
            Encoding::Alt2 => Mnemonic::ANDS,
            _ => todo!()
        }
    }

    /// Returns the instruction condition information.
    pub fn condition(instr: &Instruction) -> ConditionalInstruction {
        match instr.encoding {
            Encoding::Alt1 => {
                ConditionalInstruction::Condition(0, false, false)
            }
            Encoding::Alt2 => {
                ConditionalInstruction::None
            }
            _ => todo!()
        }
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        match instr.encoding {
            Encoding::Alt1 =>  2 ,
            Encoding::Alt2 =>  2 ,
            _ => todo!()
        }
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let Rm = (data >> 3) & 7;
        let Rm_post = Rm;
        let Rdn = (data >> 0) & 7;
        let Rdn_post = Rdn;
        let Rdn_post = Rdn;
        let Rm_post = Rm;

        // Checks if preferred encodings have been configured.
        if let Some(encoding) = decoder.config.instructions.and_r_t1.encodings {
            match encoding {
                AndRT1Encodings::Alt1 => {
                    // Operand values are computed from the base fields.
                    let op_0 = MnemonicCondition::Al;
                    let Rdn_post = Rdn;
                    let op_1 = Register::decode(Rdn_post)?;
                    let Rdn_post = Rdn;
                    let op_2 = Register::decode(Rdn_post)?;
                    let Rm_post = Rm;
                    let op_3 = Register::decode(Rm_post)?;

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::AND_r_T1, Encoding::Alt1)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .operand(3, op_3)?
                        .build();
                    
                    return Ok(instr);
                }
                AndRT1Encodings::Alt2 => {
                    // Operand values are computed from the base fields.
                    let Rdn_post = Rdn;
                    let op_0 = Register::decode(Rdn_post)?;
                    let Rdn_post = Rdn;
                    let op_1 = Register::decode(Rdn_post)?;
                    let Rm_post = Rm;
                    let op_2 = Register::decode(Rm_post)?;

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::AND_r_T1, Encoding::Alt2)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .build();
                    
                    return Ok(instr);
                }
            }
        }
        
        if (!decoder.it_block.is_none()) {
            // Operand values are computed from the base fields.
            let op_0 = MnemonicCondition::Al;
            let Rdn_post = Rdn;
            let op_1 = Register::decode(Rdn_post)?;
            let Rdn_post = Rdn;
            let op_2 = Register::decode(Rdn_post)?;
            let Rm_post = Rm;
            let op_3 = Register::decode(Rm_post)?;

            // The instruction is then created from the operands.
            let mut instr = Instruction::builder_multi(Code::AND_r_T1, Encoding::Alt1)
                .operand(0, op_0)?
                .operand(1, op_1)?
                .operand(2, op_2)?
                .operand(3, op_3)?
                .build();
            
            return Ok(instr);
        }
        
        
        if (decoder.it_block.is_none()) {
            // Operand values are computed from the base fields.
            let Rdn_post = Rdn;
            let op_0 = Register::decode(Rdn_post)?;
            let Rdn_post = Rdn;
            let op_1 = Register::decode(Rdn_post)?;
            let Rm_post = Rm;
            let op_2 = Register::decode(Rm_post)?;

            // The instruction is then created from the operands.
            let mut instr = Instruction::builder_multi(Code::AND_r_T1, Encoding::Alt2)
                .operand(0, op_0)?
                .operand(1, op_1)?
                .operand(2, op_2)?
                .build();
            
            return Ok(instr);
        }
        
        
        unreachable!()
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        match instr.encoding {
            Encoding::Alt1 => {
                // Retrieve all operand values.
                let Rdn_pre = instr.op1().as_register()?.encode();
                let Rdn_pre = instr.op2().as_register()?.encode();
                let Rm_pre = instr.op3().as_register()?.encode();

                // Compute all instruction fields from the operand values.
                let Rdn = (Rdn_pre & 7);
                let Rdn = (Rdn_pre & 7);
                let Rm = (Rm_pre & 7);

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b0100000000000000;
                instr |= (Rdn & 7) << 0;
                instr |= (Rdn & 7) << 0;
                instr |= (Rm & 7) << 3;

                let instr = instr as u16;
                buf.extend(instr.to_le_bytes());
                return Ok(2);
            }
            Encoding::Alt2 => {
                // Retrieve all operand values.
                let Rdn_pre = instr.op0().as_register()?.encode();
                let Rdn_pre = instr.op1().as_register()?.encode();
                let Rm_pre = instr.op2().as_register()?.encode();

                // Compute all instruction fields from the operand values.
                let Rdn = (Rdn_pre & 7);
                let Rdn = (Rdn_pre & 7);
                let Rm = (Rm_pre & 7);

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b0100000000000000;
                instr |= (Rdn & 7) << 0;
                instr |= (Rdn & 7) << 0;
                instr |= (Rm & 7) << 3;

                let instr = instr as u16;
                buf.extend(instr.to_le_bytes());
                return Ok(2);
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// 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> {
        match instr.encoding {
            Encoding::Alt1 => {
                Self::encode(instr, buf)
            }
            Encoding::Alt2 => {
                Self::encode(instr, buf)
            }
            _ => todo!()
        }
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                if let Operand::MnemonicCondition(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    if !instr.op1().is_none() && instr.op1().as_register()? != r {
                        todo!()
                    }
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    if !instr.op2().is_none() && instr.op2().as_register()? != r {
                        todo!()
                    }
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt2 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                todo!()
            }
            Encoding::Alt2 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                todo!()
            }
            Encoding::Alt2 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                todo!()
            }
            Encoding::Alt2 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        match instr.encoding {
            Encoding::Alt1 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.and_r_t1, &instr)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 0)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterQualifier::Narrow, true, false)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_same_reg {
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 2)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 3)?;
                return Ok(());
            }
            Encoding::Alt2 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.and_r_t1, &instr)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterQualifier::Narrow, true, false)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_same_reg {
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 0)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 1)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t1, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t1, &instr, 2)?;
                return Ok(());
            }
            _ => todo!()
        }
        unreachable!()
    }
}

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

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

// ---------------------------------------------------------------------------
// Iclass IclassAndRT2Rrx
// ---------------------------------------------------------------------------

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

impl IclassAndRT2Rrx {
    /// Tries to decode the instruction in `data`.
    pub(crate) fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        let field_31 = (data >> 25) & 127;
        let field_31_post = field_31;
        let imm3 = (data >> 12) & 7;
        let imm3_post = imm3;
        let S = (data >> 20) & 1;
        let S_post = S;
        let imm2 = (data >> 6) & 3;
        let imm2_post = imm2;
        let stype = (data >> 4) & 3;
        let stype_post = stype;
        let Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let Rd = (data >> 8) & 15;
        let Rd_post = Rd;
        let field_15 = (data >> 15) & 1;
        let field_15_post = field_15;
        let op1 = (data >> 21) & 15;
        let op1_post = op1;


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

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

        if ((S_post == 1) && ((imm3_post == 0) && ((Rd_post != 15) && ((imm2_post == 0) && (stype_post == 3))))) {
            return AndsRT2Rrx::decode(data as u32, decoder);
        }

        if ((S_post == 1) && ((Rd_post != 15) && !((((imm3_post == 0) && ((imm2_post == 0) && (stype_post == 3))))))) {
            return AndsRT2::decode(data as u32, decoder);
        }

        unreachable!()
    }
}

/// AND T2 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="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</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; border-right: none" colspan="1">0</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; 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" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">S</td>
/// <td style="text-align: center" colspan="4">Rn</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="3">imm3</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="2">imm2</td>
/// <td style="text-align: center" colspan="2">stype</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="7"></td>
/// <td style="text-align: center; border: none" colspan="4">op1</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="3"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct AndRT2Rrx;

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

    /// 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 Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let Rd = (data >> 8) & 15;
        let Rd_post = Rd;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        
        // Compute the dependency values for the operands.
        let Rd_post = Rd;
        let Rn_post = Rn;
        let Rm_post = Rm;

        // Operand values are computed from the base fields and the dependencies.
        let op_0 = MnemonicCondition::Al;
        let op_1 = Register::decode(Rd_post)?;
        let op_2 = Register::decode(Rn_post)?;
        let op_3 = Register::decode(Rm_post)?;
        let op_4 = Shift::RRX;

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

    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rn_pre = instr.op2().as_register()?.encode();
        let Rm_pre = instr.op3().as_register()?.encode();

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

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b11101010000000000000000000110000;
        instr |= (Rd & 15) << 8;
        instr |= (Rn & 15) << 16;
        instr |= (Rm & 15) << 0;

        let instr_1 = (instr & 0xffff) as u16;
        let instr_2 = ((instr >> 16) & 0xffff) as u16;
        buf.extend(instr_2.to_le_bytes());
        buf.extend(instr_1.to_le_bytes());
        Ok(4)
    }

    /// 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::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Shift(Shift::RRX) = op {
            return Ok(())
        }
        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.and_r_t2_rrx, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, FormatterTextKind::Space)?;
        if !config.global.syntax.omit_src_dst_diff_reg || instr.op1() != instr.op2() {
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
};
        fmt.format_operand(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, 3)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.and_r_t2_rrx, &instr, 4)?;
        Ok(())
    }
}

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

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

/// AND T2 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="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</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; border-right: none" colspan="1">0</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; 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" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">S</td>
/// <td style="text-align: center" colspan="4">Rn</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="3">imm3</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="2">imm2</td>
/// <td style="text-align: center" colspan="2">stype</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="7"></td>
/// <td style="text-align: center; border: none" colspan="4">op1</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="3"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct AndRT2;

impl AndRT2 {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(instr: &Instruction) -> Mnemonic {
        match instr.encoding {
            Encoding::Alt1 => Mnemonic::AND,
            Encoding::Alt2 => Mnemonic::AND,
            _ => todo!()
        }
    }

    /// Returns the instruction condition information.
    pub fn condition(instr: &Instruction) -> ConditionalInstruction {
        match instr.encoding {
            Encoding::Alt1 => {
                ConditionalInstruction::Condition(0, false, false)
            }
            Encoding::Alt2 => {
                ConditionalInstruction::Condition(0, false, false)
            }
            _ => todo!()
        }
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        match instr.encoding {
            Encoding::Alt2 =>  4,
            Encoding::Alt1 =>  4,
            _ => todo!()
        }
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let imm3 = (data >> 12) & 7;
        let imm3_post = imm3;
        let Rd = (data >> 8) & 15;
        let Rd_post = Rd;
        let imm2 = (data >> 6) & 3;
        let imm2_post = imm2;
        let stype = (data >> 4) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        let imm2_imm3_post = (imm3 << 2) | imm2;
        let Rd_post = Rd;
        let Rn_post = Rn;
        let Rm_post = Rm;

        // Checks if preferred encodings have been configured.
        if let Some(encoding) = decoder.config.instructions.and_r_t2.encodings {
            match encoding {
                AndRT2Encodings::Alt2 => {
                    // Operand values are computed from the base fields.
                    let op_0 = MnemonicCondition::Al;
                    let Rd_post = Rd;
                    let op_1 = Register::decode(Rd_post)?;
                    let Rn_post = Rn;
                    let op_2 = Register::decode(Rn_post)?;
                    let Rm_post = Rm;
                    let op_3 = Register::decode(Rm_post)?;

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::AND_r_T2, Encoding::Alt2)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .operand(3, op_3)?
                        .build();
                    
                    return Ok(instr);
                }
                AndRT2Encodings::Alt1 => {
                    // Operand values are computed from the base fields.
                    let op_0 = MnemonicCondition::Al;
                    let Rd_post = Rd;
                    let op_1 = Register::decode(Rd_post)?;
                    let Rn_post = Rn;
                    let op_2 = Register::decode(Rn_post)?;
                    let Rm_post = Rm;
                    let op_3 = Register::decode(Rm_post)?;
                    let imm2_imm3_post = (imm3 << 2) | imm2;
                    let op_4 = match stype {
    0 => if imm2_imm3_post == 0 {
            Operand::None
        } else {
            Operand::Shift(Shift::LSL(imm2_imm3_post))
        }
    1 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::LSR(32))
        } else {
            Operand::Shift(Shift::LSR(imm2_imm3_post))
        }
    2 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::ASR(32))
        } else {
            Operand::Shift(Shift::ASR(imm2_imm3_post))
        }
    3 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::RRX)
        } else {
            Operand::Shift(Shift::ROR(imm2_imm3_post))
        }
    _ => todo!(),
};

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::AND_r_T2, Encoding::Alt1)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .operand(3, op_3)?
                        .operand(4, op_4)?
                        .build();
                    
                    return Ok(instr);
                }
            }
        }
        
        if (!decoder.it_block.is_none()) && (stype_post == 0) && (imm2_imm3_post == 0) && ((Rd_post <= 7 && Rn_post <= 7 && Rm_post <= 7)) {
            // Operand values are computed from the base fields.
            let op_0 = MnemonicCondition::Al;
            let Rd_post = Rd;
            let op_1 = Register::decode(Rd_post)?;
            let Rn_post = Rn;
            let op_2 = Register::decode(Rn_post)?;
            let Rm_post = Rm;
            let op_3 = Register::decode(Rm_post)?;

            // The instruction is then created from the operands.
            let mut instr = Instruction::builder_multi(Code::AND_r_T2, Encoding::Alt2)
                .operand(0, op_0)?
                .operand(1, op_1)?
                .operand(2, op_2)?
                .operand(3, op_3)?
                .build();
            
            return Ok(instr);
        }
        
        
        // Operand values are computed from the base fields.
        let op_0 = MnemonicCondition::Al;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rn_post = Rn;
        let op_2 = Register::decode(Rn_post)?;
        let Rm_post = Rm;
        let op_3 = Register::decode(Rm_post)?;
        let imm2_imm3_post = (imm3 << 2) | imm2;
        let op_4 = match stype {
    0 => if imm2_imm3_post == 0 {
            Operand::None
        } else {
            Operand::Shift(Shift::LSL(imm2_imm3_post))
        }
    1 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::LSR(32))
        } else {
            Operand::Shift(Shift::LSR(imm2_imm3_post))
        }
    2 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::ASR(32))
        } else {
            Operand::Shift(Shift::ASR(imm2_imm3_post))
        }
    3 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::RRX)
        } else {
            Operand::Shift(Shift::ROR(imm2_imm3_post))
        }
    _ => todo!(),
};
        // The instruction is then created from the operands.
        let mut instr = Instruction::builder_multi(Code::AND_r_T2, Encoding::Alt1)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .operand(4, op_4)?
            .build();
        
        return Ok(instr);
        
        unreachable!()
    }

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

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

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b11101010000000000000000000000000;
                instr |= (Rd & 15) << 8;
                instr |= (Rn & 15) << 16;
                instr |= (Rm & 15) << 0;

                let instr_1 = (instr & 0xffff) as u16;
                let instr_2 = ((instr >> 16) & 0xffff) as u16;
                buf.extend(instr_2.to_le_bytes());
                buf.extend(instr_1.to_le_bytes());
                return Ok(4);
            }
            Encoding::Alt1 => {
                // Retrieve all operand values.
                let Rd_pre = instr.op1().as_register()?.encode();
                let Rn_pre = instr.op2().as_register()?.encode();
                let Rm_pre = instr.op3().as_register()?.encode();
                let (stype, imm2_imm3_pre) = {
    if let Operand::None = instr.op4() {
        (0, 0)
    } else {
        match instr.op4().as_shift()? {
            Shift::LSL(value) => (0, *value),
            Shift::LSR(value) => (1, *value),
            Shift::ASR(value) => (2, *value),
            Shift::ROR(value) => (3, *value),
            _ => todo!(),
        }
    }
};

                // Compute all instruction fields from the operand values.
                let Rd = (Rd_pre & 15);
                let Rn = (Rn_pre & 15);
                let Rm = (Rm_pre & 15);
                let imm2 = (imm2_imm3_pre & 3);
                let imm3 = (imm2_imm3_pre >> 2) & 7;

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b11101010000000000000000000000000;
                instr |= (Rd & 15) << 8;
                instr |= (Rn & 15) << 16;
                instr |= (Rm & 15) << 0;
                instr |= (imm2 & 3) << 6;
                instr |= (imm3 & 7) << 12;
                instr |= (stype & 3) << 4;

                let instr_1 = (instr & 0xffff) as u16;
                let instr_2 = ((instr >> 16) & 0xffff) as u16;
                buf.extend(instr_2.to_le_bytes());
                buf.extend(instr_1.to_le_bytes());
                return Ok(4);
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// 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> {
        match instr.encoding {
            Encoding::Alt2 => {
                Self::encode(instr, buf)
            }
            Encoding::Alt1 => {
                Self::encode(instr, buf)
            }
            _ => todo!()
        }
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                if let Operand::MnemonicCondition(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                if let Operand::MnemonicCondition(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                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!()
                            }
                        _ => todo!(),
                    }
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.and_r_t2, &instr)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 0)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterQualifier::Wide, true, true)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_diff_reg || instr.op1() != instr.op2() {
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 2)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 3)?;
                return Ok(());
            }
            Encoding::Alt1 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.and_r_t2, &instr)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 0)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterQualifier::Wide, true, false)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_diff_reg || instr.op1() != instr.op2() {
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 2)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 3)?;
                if !instr.op4().is_none() && !(instr.op4().as_shift()?.is_lsl() && instr.op4().as_shift()?.value() == 0) {
    fmt.format_punctuation(output, &config.global, &config.instructions.and_r_t2, &instr, FormatterTextKind::Comma)?;
    fmt.format_operand(output, &config.global, &config.instructions.and_r_t2, &instr, 4)?;
};
                return Ok(());
            }
            _ => todo!()
        }
        unreachable!()
    }
}

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

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

/// ANDS T2 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="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</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; border-right: none" colspan="1">0</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; 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" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">S</td>
/// <td style="text-align: center" colspan="4">Rn</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="3">imm3</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="2">imm2</td>
/// <td style="text-align: center" colspan="2">stype</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="7"></td>
/// <td style="text-align: center; border: none" colspan="4">op1</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="3"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct AndsRT2Rrx;

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

    /// 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 Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let Rd = (data >> 8) & 15;
        let Rd_post = Rd;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        
        // Compute the dependency values for the operands.
        let Rd_post = Rd;
        let Rn_post = Rn;
        let Rm_post = Rm;

        // Operand values are computed from the base fields and the dependencies.
        let op_0 = MnemonicCondition::Al;
        let op_1 = Register::decode(Rd_post)?;
        let op_2 = Register::decode(Rn_post)?;
        let op_3 = Register::decode(Rm_post)?;
        let op_4 = Shift::RRX;

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

    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let Rd_pre = instr.op1().as_register()?.encode();
        let Rn_pre = instr.op2().as_register()?.encode();
        let Rm_pre = instr.op3().as_register()?.encode();

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

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b11101010000100000000000000110000;
        instr |= (Rd & 15) << 8;
        instr |= (Rn & 15) << 16;
        instr |= (Rm & 15) << 0;

        let instr_1 = (instr & 0xffff) as u16;
        let instr_2 = ((instr >> 16) & 0xffff) as u16;
        buf.extend(instr_2.to_le_bytes());
        buf.extend(instr_1.to_le_bytes());
        Ok(4)
    }

    /// 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::Register(r) = op {
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Shift(Shift::RRX) = op {
            return Ok(())
        }
        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.ands_r_t2_rrx, &instr)?;
        fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, 0)?;
        fmt.format_qualifier(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, FormatterQualifier::Wide, true, false)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, FormatterTextKind::Space)?;
        if !config.global.syntax.omit_src_dst_diff_reg || instr.op1() != instr.op2() {
    fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
};
        fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, 3)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2_rrx, &instr, 4)?;
        Ok(())
    }
}

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

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

/// ANDS T2 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="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</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; border-right: none" colspan="1">0</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; 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" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">S</td>
/// <td style="text-align: center" colspan="4">Rn</td>
///          <td style="text-align: center; border-right: none" colspan="3">(0)</td>
/// <td style="text-align: center" colspan="3">imm3</td>
/// <td style="text-align: center" colspan="4">Rd</td>
/// <td style="text-align: center" colspan="2">imm2</td>
/// <td style="text-align: center" colspan="2">stype</td>
/// <td style="text-align: center" colspan="4">Rm</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="7"></td>
/// <td style="text-align: center; border: none" colspan="4">op1</td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="3"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="2"></td>
/// <td style="text-align: center; border: none" colspan="4"></td>
///     </tr>
/// </table>
pub struct AndsRT2;

impl AndsRT2 {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(instr: &Instruction) -> Mnemonic {
        match instr.encoding {
            Encoding::Alt1 => Mnemonic::ANDS,
            Encoding::Alt2 => Mnemonic::ANDS,
            _ => todo!()
        }
    }

    /// Returns the instruction condition information.
    pub fn condition(instr: &Instruction) -> ConditionalInstruction {
        match instr.encoding {
            Encoding::Alt1 => {
                ConditionalInstruction::Condition(0, false, false)
            }
            Encoding::Alt2 => {
                ConditionalInstruction::None
            }
            _ => todo!()
        }
    }

    /// Returns the instruction size.
    pub fn size(instr: &Instruction) -> usize {
        match instr.encoding {
            Encoding::Alt2 =>  4,
            Encoding::Alt1 =>  4,
            _ => todo!()
        }
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let Rn = (data >> 16) & 15;
        let Rn_post = Rn;
        let imm3 = (data >> 12) & 7;
        let imm3_post = imm3;
        let Rd = (data >> 8) & 15;
        let Rd_post = Rd;
        let imm2 = (data >> 6) & 3;
        let imm2_post = imm2;
        let stype = (data >> 4) & 3;
        let stype_post = stype;
        let Rm = (data >> 0) & 15;
        let Rm_post = Rm;
        let imm2_imm3_post = (imm3 << 2) | imm2;
        let Rd_post = Rd;
        let Rn_post = Rn;
        let Rm_post = Rm;

        // Checks if preferred encodings have been configured.
        if let Some(encoding) = decoder.config.instructions.ands_r_t2.encodings {
            match encoding {
                AndsRT2Encodings::Alt2 => {
                    // Operand values are computed from the base fields.
                    let Rd_post = Rd;
                    let op_0 = Register::decode(Rd_post)?;
                    let Rn_post = Rn;
                    let op_1 = Register::decode(Rn_post)?;
                    let Rm_post = Rm;
                    let op_2 = Register::decode(Rm_post)?;

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::ANDS_r_T2, Encoding::Alt2)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .build();
                    
                    return Ok(instr);
                }
                AndsRT2Encodings::Alt1 => {
                    // Operand values are computed from the base fields.
                    let op_0 = MnemonicCondition::Al;
                    let Rd_post = Rd;
                    let op_1 = Register::decode(Rd_post)?;
                    let Rn_post = Rn;
                    let op_2 = Register::decode(Rn_post)?;
                    let Rm_post = Rm;
                    let op_3 = Register::decode(Rm_post)?;
                    let imm2_imm3_post = (imm3 << 2) | imm2;
                    let op_4 = match stype {
    0 => if imm2_imm3_post == 0 {
            Operand::None
        } else {
            Operand::Shift(Shift::LSL(imm2_imm3_post))
        }
    1 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::LSR(32))
        } else {
            Operand::Shift(Shift::LSR(imm2_imm3_post))
        }
    2 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::ASR(32))
        } else {
            Operand::Shift(Shift::ASR(imm2_imm3_post))
        }
    3 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::RRX)
        } else {
            Operand::Shift(Shift::ROR(imm2_imm3_post))
        }
    _ => todo!(),
};

                    // The instruction is then created from the operands.
                    let mut instr = Instruction::builder_multi(Code::ANDS_r_T2, Encoding::Alt1)
                        .operand(0, op_0)?
                        .operand(1, op_1)?
                        .operand(2, op_2)?
                        .operand(3, op_3)?
                        .operand(4, op_4)?
                        .build();
                    
                    return Ok(instr);
                }
            }
        }
        
        if (decoder.it_block.is_none()) && (stype_post == 0) && (imm2_imm3_post == 0) && ((Rd_post <= 7 && Rn_post <= 7 && Rm_post <= 7)) {
            // Operand values are computed from the base fields.
            let Rd_post = Rd;
            let op_0 = Register::decode(Rd_post)?;
            let Rn_post = Rn;
            let op_1 = Register::decode(Rn_post)?;
            let Rm_post = Rm;
            let op_2 = Register::decode(Rm_post)?;

            // The instruction is then created from the operands.
            let mut instr = Instruction::builder_multi(Code::ANDS_r_T2, Encoding::Alt2)
                .operand(0, op_0)?
                .operand(1, op_1)?
                .operand(2, op_2)?
                .build();
            
            return Ok(instr);
        }
        
        
        // Operand values are computed from the base fields.
        let op_0 = MnemonicCondition::Al;
        let Rd_post = Rd;
        let op_1 = Register::decode(Rd_post)?;
        let Rn_post = Rn;
        let op_2 = Register::decode(Rn_post)?;
        let Rm_post = Rm;
        let op_3 = Register::decode(Rm_post)?;
        let imm2_imm3_post = (imm3 << 2) | imm2;
        let op_4 = match stype {
    0 => if imm2_imm3_post == 0 {
            Operand::None
        } else {
            Operand::Shift(Shift::LSL(imm2_imm3_post))
        }
    1 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::LSR(32))
        } else {
            Operand::Shift(Shift::LSR(imm2_imm3_post))
        }
    2 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::ASR(32))
        } else {
            Operand::Shift(Shift::ASR(imm2_imm3_post))
        }
    3 => if imm2_imm3_post == 0 {
            Operand::Shift(Shift::RRX)
        } else {
            Operand::Shift(Shift::ROR(imm2_imm3_post))
        }
    _ => todo!(),
};
        // The instruction is then created from the operands.
        let mut instr = Instruction::builder_multi(Code::ANDS_r_T2, Encoding::Alt1)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .operand(4, op_4)?
            .build();
        
        return Ok(instr);
        
        unreachable!()
    }

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

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

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b11101010000100000000000000000000;
                instr |= (Rd & 15) << 8;
                instr |= (Rn & 15) << 16;
                instr |= (Rm & 15) << 0;

                let instr_1 = (instr & 0xffff) as u16;
                let instr_2 = ((instr >> 16) & 0xffff) as u16;
                buf.extend(instr_2.to_le_bytes());
                buf.extend(instr_1.to_le_bytes());
                return Ok(4);
            }
            Encoding::Alt1 => {
                // Retrieve all operand values.
                let Rd_pre = instr.op1().as_register()?.encode();
                let Rn_pre = instr.op2().as_register()?.encode();
                let Rm_pre = instr.op3().as_register()?.encode();
                let (stype, imm2_imm3_pre) = {
    if let Operand::None = instr.op4() {
        (0, 0)
    } else {
        match instr.op4().as_shift()? {
            Shift::LSL(value) => (0, *value),
            Shift::LSR(value) => (1, *value),
            Shift::ASR(value) => (2, *value),
            Shift::ROR(value) => (3, *value),
            _ => todo!(),
        }
    }
};

                // Compute all instruction fields from the operand values.
                let Rd = (Rd_pre & 15);
                let Rn = (Rn_pre & 15);
                let Rm = (Rm_pre & 15);
                let imm2 = (imm2_imm3_pre & 3);
                let imm3 = (imm2_imm3_pre >> 2) & 7;

                // Add all field values to the base instruction encoding.
                let mut instr: u32 = 0b11101010000100000000000000000000;
                instr |= (Rd & 15) << 8;
                instr |= (Rn & 15) << 16;
                instr |= (Rm & 15) << 0;
                instr |= (imm2 & 3) << 6;
                instr |= (imm3 & 7) << 12;
                instr |= (stype & 3) << 4;

                let instr_1 = (instr & 0xffff) as u16;
                let instr_2 = ((instr >> 16) & 0xffff) as u16;
                buf.extend(instr_2.to_le_bytes());
                buf.extend(instr_1.to_le_bytes());
                return Ok(4);
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// 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> {
        match instr.encoding {
            Encoding::Alt2 => {
                Self::encode(instr, buf)
            }
            Encoding::Alt1 => {
                Self::encode(instr, buf)
            }
            _ => todo!()
        }
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                if let Operand::MnemonicCondition(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                
                if let Operand::Register(r) = op {
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                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!()
                            }
                        _ => todo!(),
                    }
                    return Ok(())
                }
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                todo!()
            }
            Encoding::Alt1 => {
                todo!()
            }
            _ => todo!()
        }
        unreachable!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        match instr.encoding {
            Encoding::Alt2 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.ands_r_t2, &instr)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterQualifier::Wide, true, true)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_diff_reg || instr.op0() != instr.op1() {
    fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 0)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 1)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 2)?;
                return Ok(());
            }
            Encoding::Alt1 => {
                fmt.format_mnemonic(output, &config.global, &config.instructions.ands_r_t2, &instr)?;
                fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 0)?;
                fmt.format_qualifier(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterQualifier::Wide, true, false)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Space)?;
                if !config.global.syntax.omit_src_dst_diff_reg || instr.op1() != instr.op2() {
    fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 1)?;
    fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Comma)?;
};
                fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 2)?;
                fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Comma)?;
                fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 3)?;
                if !instr.op4().is_none() && !(instr.op4().as_shift()?.is_lsl() && instr.op4().as_shift()?.value() == 0) {
    fmt.format_punctuation(output, &config.global, &config.instructions.ands_r_t2, &instr, FormatterTextKind::Comma)?;
    fmt.format_operand(output, &config.global, &config.instructions.ands_r_t2, &instr, 4)?;
};
                return Ok(());
            }
            _ => todo!()
        }
        unreachable!()
    }
}

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

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