[AArch64] Update disassembler based on 2025-06 ARM ISA data

Alongside this I also added support for decoding:

* LDR / STR (table)
* PMULLB / PMULLT
* ABS / CNT / CTZ
* SMIN / SMAX / UMIN / UMAX
* RPRFM
* PSEL

Note that while these instructions will now be disassembled, they are
not yet lifted to LLIL.

Additionally, I fixed a number of errors in the decoding of some less
commonly occurring instructions.

1 files changed, 1689 insertions, 1184 deletions

diff --git a/arch/arm64/disassembler/operations.h b/arch/arm64/disassembler/operations.h
index ce768803..d692c8b5 100644
--- a/arch/arm64/disassembler/operations.h
+++ b/arch/arm64/disassembler/operations.h
@@ -2,1189 +2,1694 @@
 #pragma once
 
 enum Operation {
-ARM64_ERROR=0,
-ARM64_ABS=1,
-ARM64_ADC=2,
-ARM64_ADCLB=3,
-ARM64_ADCLT=4,
-ARM64_ADCS=5,
-ARM64_ADD=6,
-ARM64_ADDG=7,
-ARM64_ADDHA=8,
-ARM64_ADDHN=9,
-ARM64_ADDHN2=10,
-ARM64_ADDHNB=11,
-ARM64_ADDHNT=12,
-ARM64_ADDP=13,
-ARM64_ADDPL=14,
-ARM64_ADDS=15,
-ARM64_ADDV=16,
-ARM64_ADDVA=17,
-ARM64_ADDVL=18,
-ARM64_ADR=19,
-ARM64_ADRP=20,
-ARM64_AESD=21,
-ARM64_AESE=22,
-ARM64_AESIMC=23,
-ARM64_AESMC=24,
-ARM64_AND=25,
-ARM64_ANDS=26,
-ARM64_ANDV=27,
-ARM64_ASR=28,
-ARM64_ASRD=29,
-ARM64_ASRR=30,
-ARM64_ASRV=31,
-ARM64_AT=32,
-ARM64_AUTDA=33,
-ARM64_AUTDB=34,
-ARM64_AUTDZA=35,
-ARM64_AUTDZB=36,
-ARM64_AUTIA=37,
-ARM64_AUTIA1716=38,
-ARM64_AUTIASP=39,
-ARM64_AUTIAZ=40,
-ARM64_AUTIB=41,
-ARM64_AUTIB1716=42,
-ARM64_AUTIBSP=43,
-ARM64_AUTIBZ=44,
-ARM64_AUTIZA=45,
-ARM64_AUTIZB=46,
-ARM64_AXFLAG=47,
-ARM64_B=48,
-ARM64_BCAX=49,
-ARM64_BDEP=50,
-ARM64_BEXT=51,
-ARM64_BFC=52,
-ARM64_BFCVT=53,
-ARM64_BFCVTN=54,
-ARM64_BFCVTN2=55,
-ARM64_BFCVTNT=56,
-ARM64_BFDOT=57,
-ARM64_BFI=58,
-ARM64_BFM=59,
-ARM64_BFMLAL=60,
-ARM64_BFMLALB=61,
-ARM64_BFMLALT=62,
-ARM64_BFMMLA=63,
-ARM64_BFMOPA=64,
-ARM64_BFMOPS=65,
-ARM64_BFXIL=66,
-ARM64_BGRP=67,
-ARM64_BIC=68,
-ARM64_BICS=69,
-ARM64_BIF=70,
-ARM64_BIT=71,
-ARM64_BL=72,
-ARM64_BLR=73,
-ARM64_BLRAA=74,
-ARM64_BLRAAZ=75,
-ARM64_BLRAB=76,
-ARM64_BLRABZ=77,
-ARM64_BR=78,
-ARM64_BRAA=79,
-ARM64_BRAAZ=80,
-ARM64_BRAB=81,
-ARM64_BRABZ=82,
-ARM64_BRK=83,
-ARM64_BRKA=84,
-ARM64_BRKAS=85,
-ARM64_BRKB=86,
-ARM64_BRKBS=87,
-ARM64_BRKN=88,
-ARM64_BRKNS=89,
-ARM64_BRKPA=90,
-ARM64_BRKPAS=91,
-ARM64_BRKPB=92,
-ARM64_BRKPBS=93,
-ARM64_BSL=94,
-ARM64_BSL1N=95,
-ARM64_BSL2N=96,
-ARM64_BTI=97,
-ARM64_B_AL=98,
-ARM64_B_CC=99,
-ARM64_B_CS=100,
-ARM64_B_EQ=101,
-ARM64_B_GE=102,
-ARM64_B_GT=103,
-ARM64_B_HI=104,
-ARM64_B_LE=105,
-ARM64_B_LS=106,
-ARM64_B_LT=107,
-ARM64_B_MI=108,
-ARM64_B_NE=109,
-ARM64_B_NV=110,
-ARM64_B_PL=111,
-ARM64_B_VC=112,
-ARM64_B_VS=113,
-ARM64_CADD=114,
-ARM64_CAS=115,
-ARM64_CASA=116,
-ARM64_CASAB=117,
-ARM64_CASAH=118,
-ARM64_CASAL=119,
-ARM64_CASALB=120,
-ARM64_CASALH=121,
-ARM64_CASB=122,
-ARM64_CASH=123,
-ARM64_CASL=124,
-ARM64_CASLB=125,
-ARM64_CASLH=126,
-ARM64_CASP=127,
-ARM64_CASPA=128,
-ARM64_CASPAL=129,
-ARM64_CASPL=130,
-ARM64_CBNZ=131,
-ARM64_CBZ=132,
-ARM64_CCMN=133,
-ARM64_CCMP=134,
-ARM64_CDOT=135,
-ARM64_CFINV=136,
-ARM64_CFP=137,
-ARM64_CINC=138,
-ARM64_CINV=139,
-ARM64_CLASTA=140,
-ARM64_CLASTB=141,
-ARM64_CLREX=142,
-ARM64_CLS=143,
-ARM64_CLZ=144,
-ARM64_CMEQ=145,
-ARM64_CMGE=146,
-ARM64_CMGT=147,
-ARM64_CMHI=148,
-ARM64_CMHS=149,
-ARM64_CMLA=150,
-ARM64_CMLE=151,
-ARM64_CMLT=152,
-ARM64_CMN=153,
-ARM64_CMP=154,
-ARM64_CMPEQ=155,
-ARM64_CMPGE=156,
-ARM64_CMPGT=157,
-ARM64_CMPHI=158,
-ARM64_CMPHS=159,
-ARM64_CMPLE=160,
-ARM64_CMPLO=161,
-ARM64_CMPLS=162,
-ARM64_CMPLT=163,
-ARM64_CMPNE=164,
-ARM64_CMPP=165,
-ARM64_CMTST=166,
-ARM64_CNEG=167,
-ARM64_CNOT=168,
-ARM64_CNT=169,
-ARM64_CNTB=170,
-ARM64_CNTD=171,
-ARM64_CNTH=172,
-ARM64_CNTP=173,
-ARM64_CNTW=174,
-ARM64_COMPACT=175,
-ARM64_CPP=176,
-ARM64_CPY=177,
-ARM64_CRC32B=178,
-ARM64_CRC32CB=179,
-ARM64_CRC32CH=180,
-ARM64_CRC32CW=181,
-ARM64_CRC32CX=182,
-ARM64_CRC32H=183,
-ARM64_CRC32W=184,
-ARM64_CRC32X=185,
-ARM64_CSDB=186,
-ARM64_CSEL=187,
-ARM64_CSET=188,
-ARM64_CSETM=189,
-ARM64_CSINC=190,
-ARM64_CSINV=191,
-ARM64_CSNEG=192,
-ARM64_CTERMEQ=193,
-ARM64_CTERMNE=194,
-ARM64_DC=195,
-ARM64_DCPS1=196,
-ARM64_DCPS2=197,
-ARM64_DCPS3=198,
-ARM64_DECB=199,
-ARM64_DECD=200,
-ARM64_DECH=201,
-ARM64_DECP=202,
-ARM64_DECW=203,
-ARM64_DGH=204,
-ARM64_DMB=205,
-ARM64_DRPS=206,
-ARM64_DSB=207,
-ARM64_DUP=208,
-ARM64_DUPM=209,
-ARM64_DVP=210,
-ARM64_EON=211,
-ARM64_EOR=212,
-ARM64_EOR3=213,
-ARM64_EORBT=214,
-ARM64_EORS=215,
-ARM64_EORTB=216,
-ARM64_EORV=217,
-ARM64_ERET=218,
-ARM64_ERETAA=219,
-ARM64_ERETAB=220,
-ARM64_ESB=221,
-ARM64_EXT=222,
-ARM64_EXTR=223,
-ARM64_FABD=224,
-ARM64_FABS=225,
-ARM64_FACGE=226,
-ARM64_FACGT=227,
-ARM64_FACLE=228,
-ARM64_FACLT=229,
-ARM64_FADD=230,
-ARM64_FADDA=231,
-ARM64_FADDP=232,
-ARM64_FADDV=233,
-ARM64_FCADD=234,
-ARM64_FCCMP=235,
-ARM64_FCCMPE=236,
-ARM64_FCMEQ=237,
-ARM64_FCMGE=238,
-ARM64_FCMGT=239,
-ARM64_FCMLA=240,
-ARM64_FCMLE=241,
-ARM64_FCMLT=242,
-ARM64_FCMNE=243,
-ARM64_FCMP=244,
-ARM64_FCMPE=245,
-ARM64_FCMUO=246,
-ARM64_FCPY=247,
-ARM64_FCSEL=248,
-ARM64_FCVT=249,
-ARM64_FCVTAS=250,
-ARM64_FCVTAU=251,
-ARM64_FCVTL=252,
-ARM64_FCVTL2=253,
-ARM64_FCVTLT=254,
-ARM64_FCVTMS=255,
-ARM64_FCVTMU=256,
-ARM64_FCVTN=257,
-ARM64_FCVTN2=258,
-ARM64_FCVTNS=259,
-ARM64_FCVTNT=260,
-ARM64_FCVTNU=261,
-ARM64_FCVTPS=262,
-ARM64_FCVTPU=263,
-ARM64_FCVTX=264,
-ARM64_FCVTXN=265,
-ARM64_FCVTXN2=266,
-ARM64_FCVTXNT=267,
-ARM64_FCVTZS=268,
-ARM64_FCVTZU=269,
-ARM64_FDIV=270,
-ARM64_FDIVR=271,
-ARM64_FDUP=272,
-ARM64_FEXPA=273,
-ARM64_FJCVTZS=274,
-ARM64_FLOGB=275,
-ARM64_FMAD=276,
-ARM64_FMADD=277,
-ARM64_FMAX=278,
-ARM64_FMAXNM=279,
-ARM64_FMAXNMP=280,
-ARM64_FMAXNMV=281,
-ARM64_FMAXP=282,
-ARM64_FMAXV=283,
-ARM64_FMIN=284,
-ARM64_FMINNM=285,
-ARM64_FMINNMP=286,
-ARM64_FMINNMV=287,
-ARM64_FMINP=288,
-ARM64_FMINV=289,
-ARM64_FMLA=290,
-ARM64_FMLAL=291,
-ARM64_FMLAL2=292,
-ARM64_FMLALB=293,
-ARM64_FMLALT=294,
-ARM64_FMLS=295,
-ARM64_FMLSL=296,
-ARM64_FMLSL2=297,
-ARM64_FMLSLB=298,
-ARM64_FMLSLT=299,
-ARM64_FMMLA=300,
-ARM64_FMOPA=301,
-ARM64_FMOPS=302,
-ARM64_FMOV=303,
-ARM64_FMSB=304,
-ARM64_FMSUB=305,
-ARM64_FMUL=306,
-ARM64_FMULX=307,
-ARM64_FNEG=308,
-ARM64_FNMAD=309,
-ARM64_FNMADD=310,
-ARM64_FNMLA=311,
-ARM64_FNMLS=312,
-ARM64_FNMSB=313,
-ARM64_FNMSUB=314,
-ARM64_FNMUL=315,
-ARM64_FRECPE=316,
-ARM64_FRECPS=317,
-ARM64_FRECPX=318,
-ARM64_FRINT32X=319,
-ARM64_FRINT32Z=320,
-ARM64_FRINT64X=321,
-ARM64_FRINT64Z=322,
-ARM64_FRINTA=323,
-ARM64_FRINTI=324,
-ARM64_FRINTM=325,
-ARM64_FRINTN=326,
-ARM64_FRINTP=327,
-ARM64_FRINTX=328,
-ARM64_FRINTZ=329,
-ARM64_FRSQRTE=330,
-ARM64_FRSQRTS=331,
-ARM64_FSCALE=332,
-ARM64_FSQRT=333,
-ARM64_FSUB=334,
-ARM64_FSUBR=335,
-ARM64_FTMAD=336,
-ARM64_FTSMUL=337,
-ARM64_FTSSEL=338,
-ARM64_GMI=339,
-ARM64_HINT=340,
-ARM64_HISTCNT=341,
-ARM64_HISTSEG=342,
-ARM64_HLT=343,
-ARM64_HVC=344,
-ARM64_IC=345,
-ARM64_INCB=346,
-ARM64_INCD=347,
-ARM64_INCH=348,
-ARM64_INCP=349,
-ARM64_INCW=350,
-ARM64_INDEX=351,
-ARM64_INS=352,
-ARM64_INSR=353,
-ARM64_IRG=354,
-ARM64_ISB=355,
-ARM64_LASTA=356,
-ARM64_LASTB=357,
-ARM64_LD1=358,
-ARM64_LD1B=359,
-ARM64_LD1D=360,
-ARM64_LD1H=361,
-ARM64_LD1Q=362,
-ARM64_LD1R=363,
-ARM64_LD1RB=364,
-ARM64_LD1RD=365,
-ARM64_LD1RH=366,
-ARM64_LD1ROB=367,
-ARM64_LD1ROD=368,
-ARM64_LD1ROH=369,
-ARM64_LD1ROW=370,
-ARM64_LD1RQB=371,
-ARM64_LD1RQD=372,
-ARM64_LD1RQH=373,
-ARM64_LD1RQW=374,
-ARM64_LD1RSB=375,
-ARM64_LD1RSH=376,
-ARM64_LD1RSW=377,
-ARM64_LD1RW=378,
-ARM64_LD1SB=379,
-ARM64_LD1SH=380,
-ARM64_LD1SW=381,
-ARM64_LD1W=382,
-ARM64_LD2=383,
-ARM64_LD2B=384,
-ARM64_LD2D=385,
-ARM64_LD2H=386,
-ARM64_LD2R=387,
-ARM64_LD2W=388,
-ARM64_LD3=389,
-ARM64_LD3B=390,
-ARM64_LD3D=391,
-ARM64_LD3H=392,
-ARM64_LD3R=393,
-ARM64_LD3W=394,
-ARM64_LD4=395,
-ARM64_LD4B=396,
-ARM64_LD4D=397,
-ARM64_LD4H=398,
-ARM64_LD4R=399,
-ARM64_LD4W=400,
-ARM64_LD64B=401,
-ARM64_LDADD=402,
-ARM64_LDADDA=403,
-ARM64_LDADDAB=404,
-ARM64_LDADDAH=405,
-ARM64_LDADDAL=406,
-ARM64_LDADDALB=407,
-ARM64_LDADDALH=408,
-ARM64_LDADDB=409,
-ARM64_LDADDH=410,
-ARM64_LDADDL=411,
-ARM64_LDADDLB=412,
-ARM64_LDADDLH=413,
-ARM64_LDAPR=414,
-ARM64_LDAPRB=415,
-ARM64_LDAPRH=416,
-ARM64_LDAPUR=417,
-ARM64_LDAPURB=418,
-ARM64_LDAPURH=419,
-ARM64_LDAPURSB=420,
-ARM64_LDAPURSH=421,
-ARM64_LDAPURSW=422,
-ARM64_LDAR=423,
-ARM64_LDARB=424,
-ARM64_LDARH=425,
-ARM64_LDAXP=426,
-ARM64_LDAXR=427,
-ARM64_LDAXRB=428,
-ARM64_LDAXRH=429,
-ARM64_LDCLR=430,
-ARM64_LDCLRA=431,
-ARM64_LDCLRAB=432,
-ARM64_LDCLRAH=433,
-ARM64_LDCLRAL=434,
-ARM64_LDCLRALB=435,
-ARM64_LDCLRALH=436,
-ARM64_LDCLRB=437,
-ARM64_LDCLRH=438,
-ARM64_LDCLRL=439,
-ARM64_LDCLRLB=440,
-ARM64_LDCLRLH=441,
-ARM64_LDEOR=442,
-ARM64_LDEORA=443,
-ARM64_LDEORAB=444,
-ARM64_LDEORAH=445,
-ARM64_LDEORAL=446,
-ARM64_LDEORALB=447,
-ARM64_LDEORALH=448,
-ARM64_LDEORB=449,
-ARM64_LDEORH=450,
-ARM64_LDEORL=451,
-ARM64_LDEORLB=452,
-ARM64_LDEORLH=453,
-ARM64_LDFF1B=454,
-ARM64_LDFF1D=455,
-ARM64_LDFF1H=456,
-ARM64_LDFF1SB=457,
-ARM64_LDFF1SH=458,
-ARM64_LDFF1SW=459,
-ARM64_LDFF1W=460,
-ARM64_LDG=461,
-ARM64_LDGM=462,
-ARM64_LDLAR=463,
-ARM64_LDLARB=464,
-ARM64_LDLARH=465,
-ARM64_LDNF1B=466,
-ARM64_LDNF1D=467,
-ARM64_LDNF1H=468,
-ARM64_LDNF1SB=469,
-ARM64_LDNF1SH=470,
-ARM64_LDNF1SW=471,
-ARM64_LDNF1W=472,
-ARM64_LDNP=473,
-ARM64_LDNT1B=474,
-ARM64_LDNT1D=475,
-ARM64_LDNT1H=476,
-ARM64_LDNT1SB=477,
-ARM64_LDNT1SH=478,
-ARM64_LDNT1SW=479,
-ARM64_LDNT1W=480,
-ARM64_LDP=481,
-ARM64_LDPSW=482,
-ARM64_LDR=483,
-ARM64_LDRAA=484,
-ARM64_LDRAB=485,
-ARM64_LDRB=486,
-ARM64_LDRH=487,
-ARM64_LDRSB=488,
-ARM64_LDRSH=489,
-ARM64_LDRSW=490,
-ARM64_LDSET=491,
-ARM64_LDSETA=492,
-ARM64_LDSETAB=493,
-ARM64_LDSETAH=494,
-ARM64_LDSETAL=495,
-ARM64_LDSETALB=496,
-ARM64_LDSETALH=497,
-ARM64_LDSETB=498,
-ARM64_LDSETH=499,
-ARM64_LDSETL=500,
-ARM64_LDSETLB=501,
-ARM64_LDSETLH=502,
-ARM64_LDSMAX=503,
-ARM64_LDSMAXA=504,
-ARM64_LDSMAXAB=505,
-ARM64_LDSMAXAH=506,
-ARM64_LDSMAXAL=507,
-ARM64_LDSMAXALB=508,
-ARM64_LDSMAXALH=509,
-ARM64_LDSMAXB=510,
-ARM64_LDSMAXH=511,
-ARM64_LDSMAXL=512,
-ARM64_LDSMAXLB=513,
-ARM64_LDSMAXLH=514,
-ARM64_LDSMIN=515,
-ARM64_LDSMINA=516,
-ARM64_LDSMINAB=517,
-ARM64_LDSMINAH=518,
-ARM64_LDSMINAL=519,
-ARM64_LDSMINALB=520,
-ARM64_LDSMINALH=521,
-ARM64_LDSMINB=522,
-ARM64_LDSMINH=523,
-ARM64_LDSMINL=524,
-ARM64_LDSMINLB=525,
-ARM64_LDSMINLH=526,
-ARM64_LDTR=527,
-ARM64_LDTRB=528,
-ARM64_LDTRH=529,
-ARM64_LDTRSB=530,
-ARM64_LDTRSH=531,
-ARM64_LDTRSW=532,
-ARM64_LDUMAX=533,
-ARM64_LDUMAXA=534,
-ARM64_LDUMAXAB=535,
-ARM64_LDUMAXAH=536,
-ARM64_LDUMAXAL=537,
-ARM64_LDUMAXALB=538,
-ARM64_LDUMAXALH=539,
-ARM64_LDUMAXB=540,
-ARM64_LDUMAXH=541,
-ARM64_LDUMAXL=542,
-ARM64_LDUMAXLB=543,
-ARM64_LDUMAXLH=544,
-ARM64_LDUMIN=545,
-ARM64_LDUMINA=546,
-ARM64_LDUMINAB=547,
-ARM64_LDUMINAH=548,
-ARM64_LDUMINAL=549,
-ARM64_LDUMINALB=550,
-ARM64_LDUMINALH=551,
-ARM64_LDUMINB=552,
-ARM64_LDUMINH=553,
-ARM64_LDUMINL=554,
-ARM64_LDUMINLB=555,
-ARM64_LDUMINLH=556,
-ARM64_LDUR=557,
-ARM64_LDURB=558,
-ARM64_LDURH=559,
-ARM64_LDURSB=560,
-ARM64_LDURSH=561,
-ARM64_LDURSW=562,
-ARM64_LDXP=563,
-ARM64_LDXR=564,
-ARM64_LDXRB=565,
-ARM64_LDXRH=566,
-ARM64_LSL=567,
-ARM64_LSLR=568,
-ARM64_LSLV=569,
-ARM64_LSR=570,
-ARM64_LSRR=571,
-ARM64_LSRV=572,
-ARM64_MAD=573,
-ARM64_MADD=574,
-ARM64_MATCH=575,
-ARM64_MLA=576,
-ARM64_MLS=577,
-ARM64_MNEG=578,
-ARM64_MOV=579,
-ARM64_MOVA=580,
-ARM64_MOVI=581,
-ARM64_MOVK=582,
-ARM64_MOVN=583,
-ARM64_MOVPRFX=584,
-ARM64_MOVS=585,
-ARM64_MOVZ=586,
-ARM64_MRS=587,
-ARM64_MSB=588,
-ARM64_MSR=589,
-ARM64_MSUB=590,
-ARM64_MUL=591,
-ARM64_MVN=592,
-ARM64_MVNI=593,
-ARM64_NAND=594,
-ARM64_NANDS=595,
-ARM64_NBSL=596,
-ARM64_NEG=597,
-ARM64_NEGS=598,
-ARM64_NGC=599,
-ARM64_NGCS=600,
-ARM64_NMATCH=601,
-ARM64_NOP=602,
-ARM64_NOR=603,
-ARM64_NORS=604,
-ARM64_NOT=605,
-ARM64_NOTS=606,
-ARM64_ORN=607,
-ARM64_ORNS=608,
-ARM64_ORR=609,
-ARM64_ORRS=610,
-ARM64_ORV=611,
-ARM64_PACDA=612,
-ARM64_PACDB=613,
-ARM64_PACDZA=614,
-ARM64_PACDZB=615,
-ARM64_PACGA=616,
-ARM64_PACIA=617,
-ARM64_PACIA1716=618,
-ARM64_PACIASP=619,
-ARM64_PACIAZ=620,
-ARM64_PACIB=621,
-ARM64_PACIB1716=622,
-ARM64_PACIBSP=623,
-ARM64_PACIBZ=624,
-ARM64_PACIZA=625,
-ARM64_PACIZB=626,
-ARM64_PFALSE=627,
-ARM64_PFIRST=628,
-ARM64_PMUL=629,
-ARM64_PMULL=630,
-ARM64_PMULL2=631,
-ARM64_PMULLB=632,
-ARM64_PMULLT=633,
-ARM64_PNEXT=634,
-ARM64_PRFB=635,
-ARM64_PRFD=636,
-ARM64_PRFH=637,
-ARM64_PRFM=638,
-ARM64_PRFUM=639,
-ARM64_PRFW=640,
-ARM64_PSB=641,
-ARM64_PSSBB=642,
-ARM64_PTEST=643,
-ARM64_PTRUE=644,
-ARM64_PTRUES=645,
-ARM64_PUNPKHI=646,
-ARM64_PUNPKLO=647,
-ARM64_RADDHN=648,
-ARM64_RADDHN2=649,
-ARM64_RADDHNB=650,
-ARM64_RADDHNT=651,
-ARM64_RAX1=652,
-ARM64_RBIT=653,
-ARM64_RDFFR=654,
-ARM64_RDFFRS=655,
-ARM64_RDVL=656,
-ARM64_RET=657,
-ARM64_RETAA=658,
-ARM64_RETAB=659,
-ARM64_REV=660,
-ARM64_REV16=661,
-ARM64_REV32=662,
-ARM64_REV64=663,
-ARM64_REVB=664,
-ARM64_REVD=665,
-ARM64_REVH=666,
-ARM64_REVW=667,
-ARM64_RMIF=668,
-ARM64_ROR=669,
-ARM64_RORV=670,
-ARM64_RSHRN=671,
-ARM64_RSHRN2=672,
-ARM64_RSHRNB=673,
-ARM64_RSHRNT=674,
-ARM64_RSUBHN=675,
-ARM64_RSUBHN2=676,
-ARM64_RSUBHNB=677,
-ARM64_RSUBHNT=678,
-ARM64_SABA=679,
-ARM64_SABAL=680,
-ARM64_SABAL2=681,
-ARM64_SABALB=682,
-ARM64_SABALT=683,
-ARM64_SABD=684,
-ARM64_SABDL=685,
-ARM64_SABDL2=686,
-ARM64_SABDLB=687,
-ARM64_SABDLT=688,
-ARM64_SADALP=689,
-ARM64_SADDL=690,
-ARM64_SADDL2=691,
-ARM64_SADDLB=692,
-ARM64_SADDLBT=693,
-ARM64_SADDLP=694,
-ARM64_SADDLT=695,
-ARM64_SADDLV=696,
-ARM64_SADDV=697,
-ARM64_SADDW=698,
-ARM64_SADDW2=699,
-ARM64_SADDWB=700,
-ARM64_SADDWT=701,
-ARM64_SB=702,
-ARM64_SBC=703,
-ARM64_SBCLB=704,
-ARM64_SBCLT=705,
-ARM64_SBCS=706,
-ARM64_SBFIZ=707,
-ARM64_SBFM=708,
-ARM64_SBFX=709,
-ARM64_SCLAMP=710,
-ARM64_SCVTF=711,
-ARM64_SDIV=712,
-ARM64_SDIVR=713,
-ARM64_SDOT=714,
-ARM64_SEL=715,
-ARM64_SETF16=716,
-ARM64_SETF8=717,
-ARM64_SETFFR=718,
-ARM64_SEV=719,
-ARM64_SEVL=720,
-ARM64_SHA1C=721,
-ARM64_SHA1H=722,
-ARM64_SHA1M=723,
-ARM64_SHA1P=724,
-ARM64_SHA1SU0=725,
-ARM64_SHA1SU1=726,
-ARM64_SHA256H=727,
-ARM64_SHA256H2=728,
-ARM64_SHA256SU0=729,
-ARM64_SHA256SU1=730,
-ARM64_SHA512H=731,
-ARM64_SHA512H2=732,
-ARM64_SHA512SU0=733,
-ARM64_SHA512SU1=734,
-ARM64_SHADD=735,
-ARM64_SHL=736,
-ARM64_SHLL=737,
-ARM64_SHLL2=738,
-ARM64_SHRN=739,
-ARM64_SHRN2=740,
-ARM64_SHRNB=741,
-ARM64_SHRNT=742,
-ARM64_SHSUB=743,
-ARM64_SHSUBR=744,
-ARM64_SLI=745,
-ARM64_SM3PARTW1=746,
-ARM64_SM3PARTW2=747,
-ARM64_SM3SS1=748,
-ARM64_SM3TT1A=749,
-ARM64_SM3TT1B=750,
-ARM64_SM3TT2A=751,
-ARM64_SM3TT2B=752,
-ARM64_SM4E=753,
-ARM64_SM4EKEY=754,
-ARM64_SMADDL=755,
-ARM64_SMAX=756,
-ARM64_SMAXP=757,
-ARM64_SMAXV=758,
-ARM64_SMC=759,
-ARM64_SMIN=760,
-ARM64_SMINP=761,
-ARM64_SMINV=762,
-ARM64_SMLAL=763,
-ARM64_SMLAL2=764,
-ARM64_SMLALB=765,
-ARM64_SMLALT=766,
-ARM64_SMLSL=767,
-ARM64_SMLSL2=768,
-ARM64_SMLSLB=769,
-ARM64_SMLSLT=770,
-ARM64_SMMLA=771,
-ARM64_SMNEGL=772,
-ARM64_SMOPA=773,
-ARM64_SMOPS=774,
-ARM64_SMOV=775,
-ARM64_SMSTART=776,
-ARM64_SMSTOP=777,
-ARM64_SMSUBL=778,
-ARM64_SMULH=779,
-ARM64_SMULL=780,
-ARM64_SMULL2=781,
-ARM64_SMULLB=782,
-ARM64_SMULLT=783,
-ARM64_SPLICE=784,
-ARM64_SQABS=785,
-ARM64_SQADD=786,
-ARM64_SQCADD=787,
-ARM64_SQDECB=788,
-ARM64_SQDECD=789,
-ARM64_SQDECH=790,
-ARM64_SQDECP=791,
-ARM64_SQDECW=792,
-ARM64_SQDMLAL=793,
-ARM64_SQDMLAL2=794,
-ARM64_SQDMLALB=795,
-ARM64_SQDMLALBT=796,
-ARM64_SQDMLALT=797,
-ARM64_SQDMLSL=798,
-ARM64_SQDMLSL2=799,
-ARM64_SQDMLSLB=800,
-ARM64_SQDMLSLBT=801,
-ARM64_SQDMLSLT=802,
-ARM64_SQDMULH=803,
-ARM64_SQDMULL=804,
-ARM64_SQDMULL2=805,
-ARM64_SQDMULLB=806,
-ARM64_SQDMULLT=807,
-ARM64_SQINCB=808,
-ARM64_SQINCD=809,
-ARM64_SQINCH=810,
-ARM64_SQINCP=811,
-ARM64_SQINCW=812,
-ARM64_SQNEG=813,
-ARM64_SQRDCMLAH=814,
-ARM64_SQRDMLAH=815,
-ARM64_SQRDMLSH=816,
-ARM64_SQRDMULH=817,
-ARM64_SQRSHL=818,
-ARM64_SQRSHLR=819,
-ARM64_SQRSHRN=820,
-ARM64_SQRSHRN2=821,
-ARM64_SQRSHRNB=822,
-ARM64_SQRSHRNT=823,
-ARM64_SQRSHRUN=824,
-ARM64_SQRSHRUN2=825,
-ARM64_SQRSHRUNB=826,
-ARM64_SQRSHRUNT=827,
-ARM64_SQSHL=828,
-ARM64_SQSHLR=829,
-ARM64_SQSHLU=830,
-ARM64_SQSHRN=831,
-ARM64_SQSHRN2=832,
-ARM64_SQSHRNB=833,
-ARM64_SQSHRNT=834,
-ARM64_SQSHRUN=835,
-ARM64_SQSHRUN2=836,
-ARM64_SQSHRUNB=837,
-ARM64_SQSHRUNT=838,
-ARM64_SQSUB=839,
-ARM64_SQSUBR=840,
-ARM64_SQXTN=841,
-ARM64_SQXTN2=842,
-ARM64_SQXTNB=843,
-ARM64_SQXTNT=844,
-ARM64_SQXTUN=845,
-ARM64_SQXTUN2=846,
-ARM64_SQXTUNB=847,
-ARM64_SQXTUNT=848,
-ARM64_SRHADD=849,
-ARM64_SRI=850,
-ARM64_SRSHL=851,
-ARM64_SRSHLR=852,
-ARM64_SRSHR=853,
-ARM64_SRSRA=854,
-ARM64_SSBB=855,
-ARM64_SSHL=856,
-ARM64_SSHLL=857,
-ARM64_SSHLL2=858,
-ARM64_SSHLLB=859,
-ARM64_SSHLLT=860,
-ARM64_SSHR=861,
-ARM64_SSRA=862,
-ARM64_SSUBL=863,
-ARM64_SSUBL2=864,
-ARM64_SSUBLB=865,
-ARM64_SSUBLBT=866,
-ARM64_SSUBLT=867,
-ARM64_SSUBLTB=868,
-ARM64_SSUBW=869,
-ARM64_SSUBW2=870,
-ARM64_SSUBWB=871,
-ARM64_SSUBWT=872,
-ARM64_ST1=873,
-ARM64_ST1B=874,
-ARM64_ST1D=875,
-ARM64_ST1H=876,
-ARM64_ST1Q=877,
-ARM64_ST1W=878,
-ARM64_ST2=879,
-ARM64_ST2B=880,
-ARM64_ST2D=881,
-ARM64_ST2G=882,
-ARM64_ST2H=883,
-ARM64_ST2W=884,
-ARM64_ST3=885,
-ARM64_ST3B=886,
-ARM64_ST3D=887,
-ARM64_ST3H=888,
-ARM64_ST3W=889,
-ARM64_ST4=890,
-ARM64_ST4B=891,
-ARM64_ST4D=892,
-ARM64_ST4H=893,
-ARM64_ST4W=894,
-ARM64_ST64B=895,
-ARM64_ST64BV=896,
-ARM64_ST64BV0=897,
-ARM64_STADD=898,
-ARM64_STADDB=899,
-ARM64_STADDH=900,
-ARM64_STADDL=901,
-ARM64_STADDLB=902,
-ARM64_STADDLH=903,
-ARM64_STCLR=904,
-ARM64_STCLRB=905,
-ARM64_STCLRH=906,
-ARM64_STCLRL=907,
-ARM64_STCLRLB=908,
-ARM64_STCLRLH=909,
-ARM64_STEOR=910,
-ARM64_STEORB=911,
-ARM64_STEORH=912,
-ARM64_STEORL=913,
-ARM64_STEORLB=914,
-ARM64_STEORLH=915,
-ARM64_STG=916,
-ARM64_STGM=917,
-ARM64_STGP=918,
-ARM64_STLLR=919,
-ARM64_STLLRB=920,
-ARM64_STLLRH=921,
-ARM64_STLR=922,
-ARM64_STLRB=923,
-ARM64_STLRH=924,
-ARM64_STLUR=925,
-ARM64_STLURB=926,
-ARM64_STLURH=927,
-ARM64_STLXP=928,
-ARM64_STLXR=929,
-ARM64_STLXRB=930,
-ARM64_STLXRH=931,
-ARM64_STNP=932,
-ARM64_STNT1B=933,
-ARM64_STNT1D=934,
-ARM64_STNT1H=935,
-ARM64_STNT1W=936,
-ARM64_STP=937,
-ARM64_STR=938,
-ARM64_STRB=939,
-ARM64_STRH=940,
-ARM64_STSET=941,
-ARM64_STSETB=942,
-ARM64_STSETH=943,
-ARM64_STSETL=944,
-ARM64_STSETLB=945,
-ARM64_STSETLH=946,
-ARM64_STSMAX=947,
-ARM64_STSMAXB=948,
-ARM64_STSMAXH=949,
-ARM64_STSMAXL=950,
-ARM64_STSMAXLB=951,
-ARM64_STSMAXLH=952,
-ARM64_STSMIN=953,
-ARM64_STSMINB=954,
-ARM64_STSMINH=955,
-ARM64_STSMINL=956,
-ARM64_STSMINLB=957,
-ARM64_STSMINLH=958,
-ARM64_STTR=959,
-ARM64_STTRB=960,
-ARM64_STTRH=961,
-ARM64_STUMAX=962,
-ARM64_STUMAXB=963,
-ARM64_STUMAXH=964,
-ARM64_STUMAXL=965,
-ARM64_STUMAXLB=966,
-ARM64_STUMAXLH=967,
-ARM64_STUMIN=968,
-ARM64_STUMINB=969,
-ARM64_STUMINH=970,
-ARM64_STUMINL=971,
-ARM64_STUMINLB=972,
-ARM64_STUMINLH=973,
-ARM64_STUR=974,
-ARM64_STURB=975,
-ARM64_STURH=976,
-ARM64_STXP=977,
-ARM64_STXR=978,
-ARM64_STXRB=979,
-ARM64_STXRH=980,
-ARM64_STZ2G=981,
-ARM64_STZG=982,
-ARM64_STZGM=983,
-ARM64_SUB=984,
-ARM64_SUBG=985,
-ARM64_SUBHN=986,
-ARM64_SUBHN2=987,
-ARM64_SUBHNB=988,
-ARM64_SUBHNT=989,
-ARM64_SUBP=990,
-ARM64_SUBPS=991,
-ARM64_SUBR=992,
-ARM64_SUBS=993,
-ARM64_SUDOT=994,
-ARM64_SUMOPA=995,
-ARM64_SUMOPS=996,
-ARM64_SUNPKHI=997,
-ARM64_SUNPKLO=998,
-ARM64_SUQADD=999,
-ARM64_SVC=1000,
-ARM64_SWP=1001,
-ARM64_SWPA=1002,
-ARM64_SWPAB=1003,
-ARM64_SWPAH=1004,
-ARM64_SWPAL=1005,
-ARM64_SWPALB=1006,
-ARM64_SWPALH=1007,
-ARM64_SWPB=1008,
-ARM64_SWPH=1009,
-ARM64_SWPL=1010,
-ARM64_SWPLB=1011,
-ARM64_SWPLH=1012,
-ARM64_SXTB=1013,
-ARM64_SXTH=1014,
-ARM64_SXTL=1015,
-ARM64_SXTL2=1016,
-ARM64_SXTW=1017,
-ARM64_SYS=1018,
-ARM64_SYSL=1019,
-ARM64_TBL=1020,
-ARM64_TBNZ=1021,
-ARM64_TBX=1022,
-ARM64_TBZ=1023,
-ARM64_TCANCEL=1024,
-ARM64_TCOMMIT=1025,
-ARM64_TLBI=1026,
-ARM64_TRN1=1027,
-ARM64_TRN2=1028,
-ARM64_TSB=1029,
-ARM64_TST=1030,
-ARM64_TSTART=1031,
-ARM64_TTEST=1032,
-ARM64_UABA=1033,
-ARM64_UABAL=1034,
-ARM64_UABAL2=1035,
-ARM64_UABALB=1036,
-ARM64_UABALT=1037,
-ARM64_UABD=1038,
-ARM64_UABDL=1039,
-ARM64_UABDL2=1040,
-ARM64_UABDLB=1041,
-ARM64_UABDLT=1042,
-ARM64_UADALP=1043,
-ARM64_UADDL=1044,
-ARM64_UADDL2=1045,
-ARM64_UADDLB=1046,
-ARM64_UADDLP=1047,
-ARM64_UADDLT=1048,
-ARM64_UADDLV=1049,
-ARM64_UADDV=1050,
-ARM64_UADDW=1051,
-ARM64_UADDW2=1052,
-ARM64_UADDWB=1053,
-ARM64_UADDWT=1054,
-ARM64_UBFIZ=1055,
-ARM64_UBFM=1056,
-ARM64_UBFX=1057,
-ARM64_UCLAMP=1058,
-ARM64_UCVTF=1059,
-ARM64_UDF=1060,
-ARM64_UDIV=1061,
-ARM64_UDIVR=1062,
-ARM64_UDOT=1063,
-ARM64_UHADD=1064,
-ARM64_UHSUB=1065,
-ARM64_UHSUBR=1066,
-ARM64_UMADDL=1067,
-ARM64_UMAX=1068,
-ARM64_UMAXP=1069,
-ARM64_UMAXV=1070,
-ARM64_UMIN=1071,
-ARM64_UMINP=1072,
-ARM64_UMINV=1073,
-ARM64_UMLAL=1074,
-ARM64_UMLAL2=1075,
-ARM64_UMLALB=1076,
-ARM64_UMLALT=1077,
-ARM64_UMLSL=1078,
-ARM64_UMLSL2=1079,
-ARM64_UMLSLB=1080,
-ARM64_UMLSLT=1081,
-ARM64_UMMLA=1082,
-ARM64_UMNEGL=1083,
-ARM64_UMOPA=1084,
-ARM64_UMOPS=1085,
-ARM64_UMOV=1086,
-ARM64_UMSUBL=1087,
-ARM64_UMULH=1088,
-ARM64_UMULL=1089,
-ARM64_UMULL2=1090,
-ARM64_UMULLB=1091,
-ARM64_UMULLT=1092,
-ARM64_UQADD=1093,
-ARM64_UQDECB=1094,
-ARM64_UQDECD=1095,
-ARM64_UQDECH=1096,
-ARM64_UQDECP=1097,
-ARM64_UQDECW=1098,
-ARM64_UQINCB=1099,
-ARM64_UQINCD=1100,
-ARM64_UQINCH=1101,
-ARM64_UQINCP=1102,
-ARM64_UQINCW=1103,
-ARM64_UQRSHL=1104,
-ARM64_UQRSHLR=1105,
-ARM64_UQRSHRN=1106,
-ARM64_UQRSHRN2=1107,
-ARM64_UQRSHRNB=1108,
-ARM64_UQRSHRNT=1109,
-ARM64_UQSHL=1110,
-ARM64_UQSHLR=1111,
-ARM64_UQSHRN=1112,
-ARM64_UQSHRN2=1113,
-ARM64_UQSHRNB=1114,
-ARM64_UQSHRNT=1115,
-ARM64_UQSUB=1116,
-ARM64_UQSUBR=1117,
-ARM64_UQXTN=1118,
-ARM64_UQXTN2=1119,
-ARM64_UQXTNB=1120,
-ARM64_UQXTNT=1121,
-ARM64_URECPE=1122,
-ARM64_URHADD=1123,
-ARM64_URSHL=1124,
-ARM64_URSHLR=1125,
-ARM64_URSHR=1126,
-ARM64_URSQRTE=1127,
-ARM64_URSRA=1128,
-ARM64_USDOT=1129,
-ARM64_USHL=1130,
-ARM64_USHLL=1131,
-ARM64_USHLL2=1132,
-ARM64_USHLLB=1133,
-ARM64_USHLLT=1134,
-ARM64_USHR=1135,
-ARM64_USMMLA=1136,
-ARM64_USMOPA=1137,
-ARM64_USMOPS=1138,
-ARM64_USQADD=1139,
-ARM64_USRA=1140,
-ARM64_USUBL=1141,
-ARM64_USUBL2=1142,
-ARM64_USUBLB=1143,
-ARM64_USUBLT=1144,
-ARM64_USUBW=1145,
-ARM64_USUBW2=1146,
-ARM64_USUBWB=1147,
-ARM64_USUBWT=1148,
-ARM64_UUNPKHI=1149,
-ARM64_UUNPKLO=1150,
-ARM64_UXTB=1151,
-ARM64_UXTH=1152,
-ARM64_UXTL=1153,
-ARM64_UXTL2=1154,
-ARM64_UXTW=1155,
-ARM64_UZP1=1156,
-ARM64_UZP2=1157,
-ARM64_WFE=1158,
-ARM64_WFET=1159,
-ARM64_WFI=1160,
-ARM64_WFIT=1161,
-ARM64_WHILEGE=1162,
-ARM64_WHILEGT=1163,
-ARM64_WHILEHI=1164,
-ARM64_WHILEHS=1165,
-ARM64_WHILELE=1166,
-ARM64_WHILELO=1167,
-ARM64_WHILELS=1168,
-ARM64_WHILELT=1169,
-ARM64_WHILERW=1170,
-ARM64_WHILEWR=1171,
-ARM64_WRFFR=1172,
-ARM64_XAFLAG=1173,
-ARM64_XAR=1174,
-ARM64_XPACD=1175,
-ARM64_XPACI=1176,
-ARM64_XPACLRI=1177,
-ARM64_XTN=1178,
-ARM64_XTN2=1179,
-ARM64_YIELD=1180,
-ARM64_ZERO=1181,
-ARM64_ZIP1=1182,
-ARM64_ZIP2=1183,
+	ARM64_ERROR,
+	ARM64_ABS,
+	ARM64_ADC,
+	ARM64_ADCLB,
+	ARM64_ADCLT,
+	ARM64_ADCS,
+	ARM64_ADD,
+	ARM64_ADDG,
+	ARM64_ADDHA,
+	ARM64_ADDHN,
+	ARM64_ADDHN2,
+	ARM64_ADDHNB,
+	ARM64_ADDHNT,
+	ARM64_ADDP,
+	ARM64_ADDPL,
+	ARM64_ADDPT,
+	ARM64_ADDQV,
+	ARM64_ADDS,
+	ARM64_ADDSPL,
+	ARM64_ADDSVL,
+	ARM64_ADDV,
+	ARM64_ADDVA,
+	ARM64_ADDVL,
+	ARM64_ADR,
+	ARM64_ADRP,
+	ARM64_AESD,
+	ARM64_AESDIMC,
+	ARM64_AESE,
+	ARM64_AESEMC,
+	ARM64_AESIMC,
+	ARM64_AESMC,
+	ARM64_AND,
+	ARM64_ANDQV,
+	ARM64_ANDS,
+	ARM64_ANDV,
+	ARM64_APAS,
+	ARM64_ASR,
+	ARM64_ASRD,
+	ARM64_ASRR,
+	ARM64_ASRV,
+	ARM64_AT,
+	ARM64_AUTDA,
+	ARM64_AUTDB,
+	ARM64_AUTDZA,
+	ARM64_AUTDZB,
+	ARM64_AUTIA,
+	ARM64_AUTIA1716,
+	ARM64_AUTIA171615,
+	ARM64_AUTIASP,
+	ARM64_AUTIASPPC,
+	ARM64_AUTIASPPCR,
+	ARM64_AUTIAZ,
+	ARM64_AUTIB,
+	ARM64_AUTIB1716,
+	ARM64_AUTIB171615,
+	ARM64_AUTIBSP,
+	ARM64_AUTIBSPPC,
+	ARM64_AUTIBSPPCR,
+	ARM64_AUTIBZ,
+	ARM64_AUTIZA,
+	ARM64_AUTIZB,
+	ARM64_AXFLAG,
+	ARM64_B,
+	ARM64_BC,
+	ARM64_BCAX,
+	ARM64_BDEP,
+	ARM64_BEXT,
+	ARM64_BF1CVT,
+	ARM64_BF1CVTL,
+	ARM64_BF1CVTL2,
+	ARM64_BF1CVTLT,
+	ARM64_BF2CVT,
+	ARM64_BF2CVTL,
+	ARM64_BF2CVTL2,
+	ARM64_BF2CVTLT,
+	ARM64_BFADD,
+	ARM64_BFC,
+	ARM64_BFCLAMP,
+	ARM64_BFCVT,
+	ARM64_BFCVTN,
+	ARM64_BFCVTN2,
+	ARM64_BFCVTNT,
+	ARM64_BFDOT,
+	ARM64_BFI,
+	ARM64_BFM,
+	ARM64_BFMAX,
+	ARM64_BFMAXNM,
+	ARM64_BFMIN,
+	ARM64_BFMINNM,
+	ARM64_BFMLA,
+	ARM64_BFMLAL,
+	ARM64_BFMLALB,
+	ARM64_BFMLALT,
+	ARM64_BFMLS,
+	ARM64_BFMLSL,
+	ARM64_BFMLSLB,
+	ARM64_BFMLSLT,
+	ARM64_BFMMLA,
+	ARM64_BFMOP4A,
+	ARM64_BFMOP4S,
+	ARM64_BFMOPA,
+	ARM64_BFMOPS,
+	ARM64_BFMUL,
+	ARM64_BFSCALE,
+	ARM64_BFSUB,
+	ARM64_BFTMOPA,
+	ARM64_BFVDOT,
+	ARM64_BFXIL,
+	ARM64_BGRP,
+	ARM64_BIC,
+	ARM64_BICS,
+	ARM64_BIF,
+	ARM64_BIT,
+	ARM64_BL,
+	ARM64_BLR,
+	ARM64_BLRAA,
+	ARM64_BLRAAZ,
+	ARM64_BLRAB,
+	ARM64_BLRABZ,
+	ARM64_BMOPA,
+	ARM64_BMOPS,
+	ARM64_BR,
+	ARM64_BRAA,
+	ARM64_BRAAZ,
+	ARM64_BRAB,
+	ARM64_BRABZ,
+	ARM64_BRB,
+	ARM64_BRK,
+	ARM64_BRKA,
+	ARM64_BRKAS,
+	ARM64_BRKB,
+	ARM64_BRKBS,
+	ARM64_BRKN,
+	ARM64_BRKNS,
+	ARM64_BRKPA,
+	ARM64_BRKPAS,
+	ARM64_BRKPB,
+	ARM64_BRKPBS,
+	ARM64_BSL,
+	ARM64_BSL1N,
+	ARM64_BSL2N,
+	ARM64_BTI,
+	ARM64_B_AL,
+	ARM64_B_CC,
+	ARM64_B_CS,
+	ARM64_B_EQ,
+	ARM64_B_GE,
+	ARM64_B_GT,
+	ARM64_B_HI,
+	ARM64_B_LE,
+	ARM64_B_LS,
+	ARM64_B_LT,
+	ARM64_B_MI,
+	ARM64_B_NE,
+	ARM64_B_NV,
+	ARM64_B_PL,
+	ARM64_B_VC,
+	ARM64_B_VS,
+	ARM64_CADD,
+	ARM64_CAS,
+	ARM64_CASA,
+	ARM64_CASAB,
+	ARM64_CASAH,
+	ARM64_CASAL,
+	ARM64_CASALB,
+	ARM64_CASALH,
+	ARM64_CASALT,
+	ARM64_CASAT,
+	ARM64_CASB,
+	ARM64_CASH,
+	ARM64_CASL,
+	ARM64_CASLB,
+	ARM64_CASLH,
+	ARM64_CASLT,
+	ARM64_CASP,
+	ARM64_CASPA,
+	ARM64_CASPAL,
+	ARM64_CASPALT,
+	ARM64_CASPAT,
+	ARM64_CASPL,
+	ARM64_CASPLT,
+	ARM64_CASPT,
+	ARM64_CAST,
+	ARM64_CBBEQ,
+	ARM64_CBBGE,
+	ARM64_CBBGT,
+	ARM64_CBBHI,
+	ARM64_CBBHS,
+	ARM64_CBBLE,
+	ARM64_CBBLO,
+	ARM64_CBBLS,
+	ARM64_CBBLT,
+	ARM64_CBBNE,
+	ARM64_CBEQ,
+	ARM64_CBGE,
+	ARM64_CBGT,
+	ARM64_CBHEQ,
+	ARM64_CBHGE,
+	ARM64_CBHGT,
+	ARM64_CBHHI,
+	ARM64_CBHHS,
+	ARM64_CBHI,
+	ARM64_CBHLE,
+	ARM64_CBHLO,
+	ARM64_CBHLS,
+	ARM64_CBHLT,
+	ARM64_CBHNE,
+	ARM64_CBHS,
+	ARM64_CBLE,
+	ARM64_CBLO,
+	ARM64_CBLS,
+	ARM64_CBLT,
+	ARM64_CBNE,
+	ARM64_CBNZ,
+	ARM64_CBZ,
+	ARM64_CCMN,
+	ARM64_CCMP,
+	ARM64_CDOT,
+	ARM64_CFINV,
+	ARM64_CFP,
+	ARM64_CHKFEAT,
+	ARM64_CINC,
+	ARM64_CINV,
+	ARM64_CLASTA,
+	ARM64_CLASTB,
+	ARM64_CLRBHB,
+	ARM64_CLREX,
+	ARM64_CLS,
+	ARM64_CLZ,
+	ARM64_CMEQ,
+	ARM64_CMGE,
+	ARM64_CMGT,
+	ARM64_CMHI,
+	ARM64_CMHS,
+	ARM64_CMLA,
+	ARM64_CMLE,
+	ARM64_CMLT,
+	ARM64_CMN,
+	ARM64_CMP,
+	ARM64_CMPEQ,
+	ARM64_CMPGE,
+	ARM64_CMPGT,
+	ARM64_CMPHI,
+	ARM64_CMPHS,
+	ARM64_CMPLE,
+	ARM64_CMPLO,
+	ARM64_CMPLS,
+	ARM64_CMPLT,
+	ARM64_CMPNE,
+	ARM64_CMPP,
+	ARM64_CMTST,
+	ARM64_CNEG,
+	ARM64_CNOT,
+	ARM64_CNT,
+	ARM64_CNTB,
+	ARM64_CNTD,
+	ARM64_CNTH,
+	ARM64_CNTP,
+	ARM64_CNTW,
+	ARM64_COMPACT,
+	ARM64_COSP,
+	ARM64_CPP,
+	ARM64_CPY,
+	ARM64_CPYE,
+	ARM64_CPYEN,
+	ARM64_CPYERN,
+	ARM64_CPYERT,
+	ARM64_CPYERTN,
+	ARM64_CPYERTRN,
+	ARM64_CPYERTWN,
+	ARM64_CPYET,
+	ARM64_CPYETN,
+	ARM64_CPYETRN,
+	ARM64_CPYETWN,
+	ARM64_CPYEWN,
+	ARM64_CPYEWT,
+	ARM64_CPYEWTN,
+	ARM64_CPYEWTRN,
+	ARM64_CPYEWTWN,
+	ARM64_CPYFE,
+	ARM64_CPYFEN,
+	ARM64_CPYFERN,
+	ARM64_CPYFERT,
+	ARM64_CPYFERTN,
+	ARM64_CPYFERTRN,
+	ARM64_CPYFERTWN,
+	ARM64_CPYFET,
+	ARM64_CPYFETN,
+	ARM64_CPYFETRN,
+	ARM64_CPYFETWN,
+	ARM64_CPYFEWN,
+	ARM64_CPYFEWT,
+	ARM64_CPYFEWTN,
+	ARM64_CPYFEWTRN,
+	ARM64_CPYFEWTWN,
+	ARM64_CPYFM,
+	ARM64_CPYFMN,
+	ARM64_CPYFMRN,
+	ARM64_CPYFMRT,
+	ARM64_CPYFMRTN,
+	ARM64_CPYFMRTRN,
+	ARM64_CPYFMRTWN,
+	ARM64_CPYFMT,
+	ARM64_CPYFMTN,
+	ARM64_CPYFMTRN,
+	ARM64_CPYFMTWN,
+	ARM64_CPYFMWN,
+	ARM64_CPYFMWT,
+	ARM64_CPYFMWTN,
+	ARM64_CPYFMWTRN,
+	ARM64_CPYFMWTWN,
+	ARM64_CPYFP,
+	ARM64_CPYFPN,
+	ARM64_CPYFPRN,
+	ARM64_CPYFPRT,
+	ARM64_CPYFPRTN,
+	ARM64_CPYFPRTRN,
+	ARM64_CPYFPRTWN,
+	ARM64_CPYFPT,
+	ARM64_CPYFPTN,
+	ARM64_CPYFPTRN,
+	ARM64_CPYFPTWN,
+	ARM64_CPYFPWN,
+	ARM64_CPYFPWT,
+	ARM64_CPYFPWTN,
+	ARM64_CPYFPWTRN,
+	ARM64_CPYFPWTWN,
+	ARM64_CPYM,
+	ARM64_CPYMN,
+	ARM64_CPYMRN,
+	ARM64_CPYMRT,
+	ARM64_CPYMRTN,
+	ARM64_CPYMRTRN,
+	ARM64_CPYMRTWN,
+	ARM64_CPYMT,
+	ARM64_CPYMTN,
+	ARM64_CPYMTRN,
+	ARM64_CPYMTWN,
+	ARM64_CPYMWN,
+	ARM64_CPYMWT,
+	ARM64_CPYMWTN,
+	ARM64_CPYMWTRN,
+	ARM64_CPYMWTWN,
+	ARM64_CPYP,
+	ARM64_CPYPN,
+	ARM64_CPYPRN,
+	ARM64_CPYPRT,
+	ARM64_CPYPRTN,
+	ARM64_CPYPRTRN,
+	ARM64_CPYPRTWN,
+	ARM64_CPYPT,
+	ARM64_CPYPTN,
+	ARM64_CPYPTRN,
+	ARM64_CPYPTWN,
+	ARM64_CPYPWN,
+	ARM64_CPYPWT,
+	ARM64_CPYPWTN,
+	ARM64_CPYPWTRN,
+	ARM64_CPYPWTWN,
+	ARM64_CRC32B,
+	ARM64_CRC32CB,
+	ARM64_CRC32CH,
+	ARM64_CRC32CW,
+	ARM64_CRC32CX,
+	ARM64_CRC32H,
+	ARM64_CRC32W,
+	ARM64_CRC32X,
+	ARM64_CSDB,
+	ARM64_CSEL,
+	ARM64_CSET,
+	ARM64_CSETM,
+	ARM64_CSINC,
+	ARM64_CSINV,
+	ARM64_CSNEG,
+	ARM64_CTERMEQ,
+	ARM64_CTERMNE,
+	ARM64_CTZ,
+	ARM64_DC,
+	ARM64_DCPS1,
+	ARM64_DCPS2,
+	ARM64_DCPS3,
+	ARM64_DECB,
+	ARM64_DECD,
+	ARM64_DECH,
+	ARM64_DECP,
+	ARM64_DECW,
+	ARM64_DGH,
+	ARM64_DMB,
+	ARM64_DRPS,
+	ARM64_DSB,
+	ARM64_DUP,
+	ARM64_DUPM,
+	ARM64_DUPQ,
+	ARM64_DVP,
+	ARM64_EON,
+	ARM64_EOR,
+	ARM64_EOR3,
+	ARM64_EORBT,
+	ARM64_EORQV,
+	ARM64_EORS,
+	ARM64_EORTB,
+	ARM64_EORV,
+	ARM64_ERET,
+	ARM64_ERETAA,
+	ARM64_ERETAB,
+	ARM64_ESB,
+	ARM64_EXPAND,
+	ARM64_EXT,
+	ARM64_EXTQ,
+	ARM64_EXTR,
+	ARM64_F1CVT,
+	ARM64_F1CVTL,
+	ARM64_F1CVTL2,
+	ARM64_F1CVTLT,
+	ARM64_F2CVT,
+	ARM64_F2CVTL,
+	ARM64_F2CVTL2,
+	ARM64_F2CVTLT,
+	ARM64_FABD,
+	ARM64_FABS,
+	ARM64_FACGE,
+	ARM64_FACGT,
+	ARM64_FACLE,
+	ARM64_FACLT,
+	ARM64_FADD,
+	ARM64_FADDA,
+	ARM64_FADDP,
+	ARM64_FADDQV,
+	ARM64_FADDV,
+	ARM64_FAMAX,
+	ARM64_FAMIN,
+	ARM64_FCADD,
+	ARM64_FCCMP,
+	ARM64_FCCMPE,
+	ARM64_FCLAMP,
+	ARM64_FCMEQ,
+	ARM64_FCMGE,
+	ARM64_FCMGT,
+	ARM64_FCMLA,
+	ARM64_FCMLE,
+	ARM64_FCMLT,
+	ARM64_FCMNE,
+	ARM64_FCMP,
+	ARM64_FCMPE,
+	ARM64_FCMUO,
+	ARM64_FCPY,
+	ARM64_FCSEL,
+	ARM64_FCVT,
+	ARM64_FCVTAS,
+	ARM64_FCVTAU,
+	ARM64_FCVTL,
+	ARM64_FCVTL2,
+	ARM64_FCVTLT,
+	ARM64_FCVTMS,
+	ARM64_FCVTMU,
+	ARM64_FCVTN,
+	ARM64_FCVTN2,
+	ARM64_FCVTNB,
+	ARM64_FCVTNS,
+	ARM64_FCVTNT,
+	ARM64_FCVTNU,
+	ARM64_FCVTPS,
+	ARM64_FCVTPU,
+	ARM64_FCVTX,
+	ARM64_FCVTXN,
+	ARM64_FCVTXN2,
+	ARM64_FCVTXNT,
+	ARM64_FCVTZS,
+	ARM64_FCVTZU,
+	ARM64_FDIV,
+	ARM64_FDIVR,
+	ARM64_FDOT,
+	ARM64_FDUP,
+	ARM64_FEXPA,
+	ARM64_FIRSTP,
+	ARM64_FJCVTZS,
+	ARM64_FLOGB,
+	ARM64_FMAD,
+	ARM64_FMADD,
+	ARM64_FMAX,
+	ARM64_FMAXNM,
+	ARM64_FMAXNMP,
+	ARM64_FMAXNMQV,
+	ARM64_FMAXNMV,
+	ARM64_FMAXP,
+	ARM64_FMAXQV,
+	ARM64_FMAXV,
+	ARM64_FMIN,
+	ARM64_FMINNM,
+	ARM64_FMINNMP,
+	ARM64_FMINNMQV,
+	ARM64_FMINNMV,
+	ARM64_FMINP,
+	ARM64_FMINQV,
+	ARM64_FMINV,
+	ARM64_FMLA,
+	ARM64_FMLAL,
+	ARM64_FMLAL2,
+	ARM64_FMLALB,
+	ARM64_FMLALL,
+	ARM64_FMLALLBB,
+	ARM64_FMLALLBT,
+	ARM64_FMLALLTB,
+	ARM64_FMLALLTT,
+	ARM64_FMLALT,
+	ARM64_FMLS,
+	ARM64_FMLSL,
+	ARM64_FMLSL2,
+	ARM64_FMLSLB,
+	ARM64_FMLSLT,
+	ARM64_FMMLA,
+	ARM64_FMOP4A,
+	ARM64_FMOP4S,
+	ARM64_FMOPA,
+	ARM64_FMOPS,
+	ARM64_FMOV,
+	ARM64_FMSB,
+	ARM64_FMSUB,
+	ARM64_FMUL,
+	ARM64_FMULX,
+	ARM64_FNEG,
+	ARM64_FNMAD,
+	ARM64_FNMADD,
+	ARM64_FNMLA,
+	ARM64_FNMLS,
+	ARM64_FNMSB,
+	ARM64_FNMSUB,
+	ARM64_FNMUL,
+	ARM64_FRECPE,
+	ARM64_FRECPS,
+	ARM64_FRECPX,
+	ARM64_FRINT32X,
+	ARM64_FRINT32Z,
+	ARM64_FRINT64X,
+	ARM64_FRINT64Z,
+	ARM64_FRINTA,
+	ARM64_FRINTI,
+	ARM64_FRINTM,
+	ARM64_FRINTN,
+	ARM64_FRINTP,
+	ARM64_FRINTX,
+	ARM64_FRINTZ,
+	ARM64_FRSQRTE,
+	ARM64_FRSQRTS,
+	ARM64_FSCALE,
+	ARM64_FSQRT,
+	ARM64_FSUB,
+	ARM64_FSUBR,
+	ARM64_FTMAD,
+	ARM64_FTMOPA,
+	ARM64_FTSMUL,
+	ARM64_FTSSEL,
+	ARM64_FVDOT,
+	ARM64_FVDOTB,
+	ARM64_FVDOTT,
+	ARM64_GCSB,
+	ARM64_GCSPOPCX,
+	ARM64_GCSPOPM,
+	ARM64_GCSPOPX,
+	ARM64_GCSPUSHM,
+	ARM64_GCSPUSHX,
+	ARM64_GCSSS1,
+	ARM64_GCSSS2,
+	ARM64_GCSSTR,
+	ARM64_GCSSTTR,
+	ARM64_GMI,
+	ARM64_HINT,
+	ARM64_HISTCNT,
+	ARM64_HISTSEG,
+	ARM64_HLT,
+	ARM64_HVC,
+	ARM64_IC,
+	ARM64_INCB,
+	ARM64_INCD,
+	ARM64_INCH,
+	ARM64_INCP,
+	ARM64_INCW,
+	ARM64_INDEX,
+	ARM64_INS,
+	ARM64_INSR,
+	ARM64_IRG,
+	ARM64_ISB,
+	ARM64_LASTA,
+	ARM64_LASTB,
+	ARM64_LASTP,
+	ARM64_LD1,
+	ARM64_LD1B,
+	ARM64_LD1D,
+	ARM64_LD1H,
+	ARM64_LD1Q,
+	ARM64_LD1R,
+	ARM64_LD1RB,
+	ARM64_LD1RD,
+	ARM64_LD1RH,
+	ARM64_LD1ROB,
+	ARM64_LD1ROD,
+	ARM64_LD1ROH,
+	ARM64_LD1ROW,
+	ARM64_LD1RQB,
+	ARM64_LD1RQD,
+	ARM64_LD1RQH,
+	ARM64_LD1RQW,
+	ARM64_LD1RSB,
+	ARM64_LD1RSH,
+	ARM64_LD1RSW,
+	ARM64_LD1RW,
+	ARM64_LD1SB,
+	ARM64_LD1SH,
+	ARM64_LD1SW,
+	ARM64_LD1W,
+	ARM64_LD2,
+	ARM64_LD2B,
+	ARM64_LD2D,
+	ARM64_LD2H,
+	ARM64_LD2Q,
+	ARM64_LD2R,
+	ARM64_LD2W,
+	ARM64_LD3,
+	ARM64_LD3B,
+	ARM64_LD3D,
+	ARM64_LD3H,
+	ARM64_LD3Q,
+	ARM64_LD3R,
+	ARM64_LD3W,
+	ARM64_LD4,
+	ARM64_LD4B,
+	ARM64_LD4D,
+	ARM64_LD4H,
+	ARM64_LD4Q,
+	ARM64_LD4R,
+	ARM64_LD4W,
+	ARM64_LD64B,
+	ARM64_LDADD,
+	ARM64_LDADDA,
+	ARM64_LDADDAB,
+	ARM64_LDADDAH,
+	ARM64_LDADDAL,
+	ARM64_LDADDALB,
+	ARM64_LDADDALH,
+	ARM64_LDADDB,
+	ARM64_LDADDH,
+	ARM64_LDADDL,
+	ARM64_LDADDLB,
+	ARM64_LDADDLH,
+	ARM64_LDAP1,
+	ARM64_LDAPR,
+	ARM64_LDAPRB,
+	ARM64_LDAPRH,
+	ARM64_LDAPUR,
+	ARM64_LDAPURB,
+	ARM64_LDAPURH,
+	ARM64_LDAPURSB,
+	ARM64_LDAPURSH,
+	ARM64_LDAPURSW,
+	ARM64_LDAR,
+	ARM64_LDARB,
+	ARM64_LDARH,
+	ARM64_LDATXR,
+	ARM64_LDAXP,
+	ARM64_LDAXR,
+	ARM64_LDAXRB,
+	ARM64_LDAXRH,
+	ARM64_LDBFADD,
+	ARM64_LDBFADDA,
+	ARM64_LDBFADDAL,
+	ARM64_LDBFADDL,
+	ARM64_LDBFMAX,
+	ARM64_LDBFMAXA,
+	ARM64_LDBFMAXAL,
+	ARM64_LDBFMAXL,
+	ARM64_LDBFMAXNM,
+	ARM64_LDBFMAXNMA,
+	ARM64_LDBFMAXNMAL,
+	ARM64_LDBFMAXNML,
+	ARM64_LDBFMIN,
+	ARM64_LDBFMINA,
+	ARM64_LDBFMINAL,
+	ARM64_LDBFMINL,
+	ARM64_LDBFMINNM,
+	ARM64_LDBFMINNMA,
+	ARM64_LDBFMINNMAL,
+	ARM64_LDBFMINNML,
+	ARM64_LDCLR,
+	ARM64_LDCLRA,
+	ARM64_LDCLRAB,
+	ARM64_LDCLRAH,
+	ARM64_LDCLRAL,
+	ARM64_LDCLRALB,
+	ARM64_LDCLRALH,
+	ARM64_LDCLRB,
+	ARM64_LDCLRH,
+	ARM64_LDCLRL,
+	ARM64_LDCLRLB,
+	ARM64_LDCLRLH,
+	ARM64_LDCLRP,
+	ARM64_LDCLRPA,
+	ARM64_LDCLRPAL,
+	ARM64_LDCLRPL,
+	ARM64_LDEOR,
+	ARM64_LDEORA,
+	ARM64_LDEORAB,
+	ARM64_LDEORAH,
+	ARM64_LDEORAL,
+	ARM64_LDEORALB,
+	ARM64_LDEORALH,
+	ARM64_LDEORB,
+	ARM64_LDEORH,
+	ARM64_LDEORL,
+	ARM64_LDEORLB,
+	ARM64_LDEORLH,
+	ARM64_LDFADD,
+	ARM64_LDFADDA,
+	ARM64_LDFADDAL,
+	ARM64_LDFADDL,
+	ARM64_LDFF1B,
+	ARM64_LDFF1D,
+	ARM64_LDFF1H,
+	ARM64_LDFF1SB,
+	ARM64_LDFF1SH,
+	ARM64_LDFF1SW,
+	ARM64_LDFF1W,
+	ARM64_LDFMAX,
+	ARM64_LDFMAXA,
+	ARM64_LDFMAXAL,
+	ARM64_LDFMAXL,
+	ARM64_LDFMAXNM,
+	ARM64_LDFMAXNMA,
+	ARM64_LDFMAXNMAL,
+	ARM64_LDFMAXNML,
+	ARM64_LDFMIN,
+	ARM64_LDFMINA,
+	ARM64_LDFMINAL,
+	ARM64_LDFMINL,
+	ARM64_LDFMINNM,
+	ARM64_LDFMINNMA,
+	ARM64_LDFMINNMAL,
+	ARM64_LDFMINNML,
+	ARM64_LDG,
+	ARM64_LDGM,
+	ARM64_LDIAPP,
+	ARM64_LDLAR,
+	ARM64_LDLARB,
+	ARM64_LDLARH,
+	ARM64_LDNF1B,
+	ARM64_LDNF1D,
+	ARM64_LDNF1H,
+	ARM64_LDNF1SB,
+	ARM64_LDNF1SH,
+	ARM64_LDNF1SW,
+	ARM64_LDNF1W,
+	ARM64_LDNP,
+	ARM64_LDNT1B,
+	ARM64_LDNT1D,
+	ARM64_LDNT1H,
+	ARM64_LDNT1SB,
+	ARM64_LDNT1SH,
+	ARM64_LDNT1SW,
+	ARM64_LDNT1W,
+	ARM64_LDP,
+	ARM64_LDPSW,
+	ARM64_LDR,
+	ARM64_LDRAA,
+	ARM64_LDRAB,
+	ARM64_LDRB,
+	ARM64_LDRH,
+	ARM64_LDRSB,
+	ARM64_LDRSH,
+	ARM64_LDRSW,
+	ARM64_LDSET,
+	ARM64_LDSETA,
+	ARM64_LDSETAB,
+	ARM64_LDSETAH,
+	ARM64_LDSETAL,
+	ARM64_LDSETALB,
+	ARM64_LDSETALH,
+	ARM64_LDSETB,
+	ARM64_LDSETH,
+	ARM64_LDSETL,
+	ARM64_LDSETLB,
+	ARM64_LDSETLH,
+	ARM64_LDSETP,
+	ARM64_LDSETPA,
+	ARM64_LDSETPAL,
+	ARM64_LDSETPL,
+	ARM64_LDSMAX,
+	ARM64_LDSMAXA,
+	ARM64_LDSMAXAB,
+	ARM64_LDSMAXAH,
+	ARM64_LDSMAXAL,
+	ARM64_LDSMAXALB,
+	ARM64_LDSMAXALH,
+	ARM64_LDSMAXB,
+	ARM64_LDSMAXH,
+	ARM64_LDSMAXL,
+	ARM64_LDSMAXLB,
+	ARM64_LDSMAXLH,
+	ARM64_LDSMIN,
+	ARM64_LDSMINA,
+	ARM64_LDSMINAB,
+	ARM64_LDSMINAH,
+	ARM64_LDSMINAL,
+	ARM64_LDSMINALB,
+	ARM64_LDSMINALH,
+	ARM64_LDSMINB,
+	ARM64_LDSMINH,
+	ARM64_LDSMINL,
+	ARM64_LDSMINLB,
+	ARM64_LDSMINLH,
+	ARM64_LDTADD,
+	ARM64_LDTADDA,
+	ARM64_LDTADDAL,
+	ARM64_LDTADDL,
+	ARM64_LDTCLR,
+	ARM64_LDTCLRA,
+	ARM64_LDTCLRAL,
+	ARM64_LDTCLRL,
+	ARM64_LDTNP,
+	ARM64_LDTP,
+	ARM64_LDTR,
+	ARM64_LDTRB,
+	ARM64_LDTRH,
+	ARM64_LDTRSB,
+	ARM64_LDTRSH,
+	ARM64_LDTRSW,
+	ARM64_LDTSET,
+	ARM64_LDTSETA,
+	ARM64_LDTSETAL,
+	ARM64_LDTSETL,
+	ARM64_LDTXR,
+	ARM64_LDUMAX,
+	ARM64_LDUMAXA,
+	ARM64_LDUMAXAB,
+	ARM64_LDUMAXAH,
+	ARM64_LDUMAXAL,
+	ARM64_LDUMAXALB,
+	ARM64_LDUMAXALH,
+	ARM64_LDUMAXB,
+	ARM64_LDUMAXH,
+	ARM64_LDUMAXL,
+	ARM64_LDUMAXLB,
+	ARM64_LDUMAXLH,
+	ARM64_LDUMIN,
+	ARM64_LDUMINA,
+	ARM64_LDUMINAB,
+	ARM64_LDUMINAH,
+	ARM64_LDUMINAL,
+	ARM64_LDUMINALB,
+	ARM64_LDUMINALH,
+	ARM64_LDUMINB,
+	ARM64_LDUMINH,
+	ARM64_LDUMINL,
+	ARM64_LDUMINLB,
+	ARM64_LDUMINLH,
+	ARM64_LDUR,
+	ARM64_LDURB,
+	ARM64_LDURH,
+	ARM64_LDURSB,
+	ARM64_LDURSH,
+	ARM64_LDURSW,
+	ARM64_LDXP,
+	ARM64_LDXR,
+	ARM64_LDXRB,
+	ARM64_LDXRH,
+	ARM64_LSL,
+	ARM64_LSLR,
+	ARM64_LSLV,
+	ARM64_LSR,
+	ARM64_LSRR,
+	ARM64_LSRV,
+	ARM64_LUTI2,
+	ARM64_LUTI4,
+	ARM64_MAD,
+	ARM64_MADD,
+	ARM64_MADDPT,
+	ARM64_MADPT,
+	ARM64_MATCH,
+	ARM64_MLA,
+	ARM64_MLAPT,
+	ARM64_MLS,
+	ARM64_MNEG,
+	ARM64_MOV,
+	ARM64_MOVA,
+	ARM64_MOVAZ,
+	ARM64_MOVI,
+	ARM64_MOVK,
+	ARM64_MOVN,
+	ARM64_MOVPRFX,
+	ARM64_MOVS,
+	ARM64_MOVT,
+	ARM64_MOVZ,
+	ARM64_MRRS,
+	ARM64_MRS,
+	ARM64_MSB,
+	ARM64_MSR,
+	ARM64_MSRR,
+	ARM64_MSUB,
+	ARM64_MSUBPT,
+	ARM64_MUL,
+	ARM64_MVN,
+	ARM64_MVNI,
+	ARM64_NAND,
+	ARM64_NANDS,
+	ARM64_NBSL,
+	ARM64_NEG,
+	ARM64_NEGS,
+	ARM64_NGC,
+	ARM64_NGCS,
+	ARM64_NMATCH,
+	ARM64_NOP,
+	ARM64_NOR,
+	ARM64_NORS,
+	ARM64_NOT,
+	ARM64_NOTS,
+	ARM64_ORN,
+	ARM64_ORNS,
+	ARM64_ORQV,
+	ARM64_ORR,
+	ARM64_ORRS,
+	ARM64_ORV,
+	ARM64_PACDA,
+	ARM64_PACDB,
+	ARM64_PACDZA,
+	ARM64_PACDZB,
+	ARM64_PACGA,
+	ARM64_PACIA,
+	ARM64_PACIA1716,
+	ARM64_PACIA171615,
+	ARM64_PACIASP,
+	ARM64_PACIASPPC,
+	ARM64_PACIAZ,
+	ARM64_PACIB,
+	ARM64_PACIB1716,
+	ARM64_PACIB171615,
+	ARM64_PACIBSP,
+	ARM64_PACIBSPPC,
+	ARM64_PACIBZ,
+	ARM64_PACIZA,
+	ARM64_PACIZB,
+	ARM64_PACM,
+	ARM64_PACNBIASPPC,
+	ARM64_PACNBIBSPPC,
+	ARM64_PEXT,
+	ARM64_PFALSE,
+	ARM64_PFIRST,
+	ARM64_PMLAL,
+	ARM64_PMOV,
+	ARM64_PMUL,
+	ARM64_PMULL,
+	ARM64_PMULL2,
+	ARM64_PMULLB,
+	ARM64_PMULLT,
+	ARM64_PNEXT,
+	ARM64_PRFB,
+	ARM64_PRFD,
+	ARM64_PRFH,
+	ARM64_PRFM,
+	ARM64_PRFUM,
+	ARM64_PRFW,
+	ARM64_PSB,
+	ARM64_PSEL,
+	ARM64_PSSBB,
+	ARM64_PTEST,
+	ARM64_PTRUE,
+	ARM64_PTRUES,
+	ARM64_PUNPKHI,
+	ARM64_PUNPKLO,
+	ARM64_RADDHN,
+	ARM64_RADDHN2,
+	ARM64_RADDHNB,
+	ARM64_RADDHNT,
+	ARM64_RAX1,
+	ARM64_RBIT,
+	ARM64_RCWCAS,
+	ARM64_RCWCASA,
+	ARM64_RCWCASAL,
+	ARM64_RCWCASL,
+	ARM64_RCWCASP,
+	ARM64_RCWCASPA,
+	ARM64_RCWCASPAL,
+	ARM64_RCWCASPL,
+	ARM64_RCWCLR,
+	ARM64_RCWCLRA,
+	ARM64_RCWCLRAL,
+	ARM64_RCWCLRL,
+	ARM64_RCWCLRP,
+	ARM64_RCWCLRPA,
+	ARM64_RCWCLRPAL,
+	ARM64_RCWCLRPL,
+	ARM64_RCWSCAS,
+	ARM64_RCWSCASA,
+	ARM64_RCWSCASAL,
+	ARM64_RCWSCASL,
+	ARM64_RCWSCASP,
+	ARM64_RCWSCASPA,
+	ARM64_RCWSCASPAL,
+	ARM64_RCWSCASPL,
+	ARM64_RCWSCLR,
+	ARM64_RCWSCLRA,
+	ARM64_RCWSCLRAL,
+	ARM64_RCWSCLRL,
+	ARM64_RCWSCLRP,
+	ARM64_RCWSCLRPA,
+	ARM64_RCWSCLRPAL,
+	ARM64_RCWSCLRPL,
+	ARM64_RCWSET,
+	ARM64_RCWSETA,
+	ARM64_RCWSETAL,
+	ARM64_RCWSETL,
+	ARM64_RCWSETP,
+	ARM64_RCWSETPA,
+	ARM64_RCWSETPAL,
+	ARM64_RCWSETPL,
+	ARM64_RCWSSET,
+	ARM64_RCWSSETA,
+	ARM64_RCWSSETAL,
+	ARM64_RCWSSETL,
+	ARM64_RCWSSETP,
+	ARM64_RCWSSETPA,
+	ARM64_RCWSSETPAL,
+	ARM64_RCWSSETPL,
+	ARM64_RCWSSWP,
+	ARM64_RCWSSWPA,
+	ARM64_RCWSSWPAL,
+	ARM64_RCWSSWPL,
+	ARM64_RCWSSWPP,
+	ARM64_RCWSSWPPA,
+	ARM64_RCWSSWPPAL,
+	ARM64_RCWSSWPPL,
+	ARM64_RCWSWP,
+	ARM64_RCWSWPA,
+	ARM64_RCWSWPAL,
+	ARM64_RCWSWPL,
+	ARM64_RCWSWPP,
+	ARM64_RCWSWPPA,
+	ARM64_RCWSWPPAL,
+	ARM64_RCWSWPPL,
+	ARM64_RDFFR,
+	ARM64_RDFFRS,
+	ARM64_RDSVL,
+	ARM64_RDVL,
+	ARM64_RET,
+	ARM64_RETAA,
+	ARM64_RETAASPPC,
+	ARM64_RETAASPPCR,
+	ARM64_RETAB,
+	ARM64_RETABSPPC,
+	ARM64_RETABSPPCR,
+	ARM64_REV,
+	ARM64_REV16,
+	ARM64_REV32,
+	ARM64_REV64,
+	ARM64_REVB,
+	ARM64_REVD,
+	ARM64_REVH,
+	ARM64_REVW,
+	ARM64_RMIF,
+	ARM64_ROR,
+	ARM64_RORV,
+	ARM64_RPRFM,
+	ARM64_RSHRN,
+	ARM64_RSHRN2,
+	ARM64_RSHRNB,
+	ARM64_RSHRNT,
+	ARM64_RSUBHN,
+	ARM64_RSUBHN2,
+	ARM64_RSUBHNB,
+	ARM64_RSUBHNT,
+	ARM64_SABA,
+	ARM64_SABAL,
+	ARM64_SABAL2,
+	ARM64_SABALB,
+	ARM64_SABALT,
+	ARM64_SABD,
+	ARM64_SABDL,
+	ARM64_SABDL2,
+	ARM64_SABDLB,
+	ARM64_SABDLT,
+	ARM64_SADALP,
+	ARM64_SADDL,
+	ARM64_SADDL2,
+	ARM64_SADDLB,
+	ARM64_SADDLBT,
+	ARM64_SADDLP,
+	ARM64_SADDLT,
+	ARM64_SADDLV,
+	ARM64_SADDV,
+	ARM64_SADDW,
+	ARM64_SADDW2,
+	ARM64_SADDWB,
+	ARM64_SADDWT,
+	ARM64_SB,
+	ARM64_SBC,
+	ARM64_SBCLB,
+	ARM64_SBCLT,
+	ARM64_SBCS,
+	ARM64_SBFIZ,
+	ARM64_SBFM,
+	ARM64_SBFX,
+	ARM64_SCLAMP,
+	ARM64_SCVTF,
+	ARM64_SDIV,
+	ARM64_SDIVR,
+	ARM64_SDOT,
+	ARM64_SEL,
+	ARM64_SETE,
+	ARM64_SETEN,
+	ARM64_SETET,
+	ARM64_SETETN,
+	ARM64_SETF16,
+	ARM64_SETF8,
+	ARM64_SETFFR,
+	ARM64_SETGE,
+	ARM64_SETGEN,
+	ARM64_SETGET,
+	ARM64_SETGETN,
+	ARM64_SETGM,
+	ARM64_SETGMN,
+	ARM64_SETGMT,
+	ARM64_SETGMTN,
+	ARM64_SETGP,
+	ARM64_SETGPN,
+	ARM64_SETGPT,
+	ARM64_SETGPTN,
+	ARM64_SETM,
+	ARM64_SETMN,
+	ARM64_SETMT,
+	ARM64_SETMTN,
+	ARM64_SETP,
+	ARM64_SETPN,
+	ARM64_SETPT,
+	ARM64_SETPTN,
+	ARM64_SEV,
+	ARM64_SEVL,
+	ARM64_SHA1C,
+	ARM64_SHA1H,
+	ARM64_SHA1M,
+	ARM64_SHA1P,
+	ARM64_SHA1SU0,
+	ARM64_SHA1SU1,
+	ARM64_SHA256H,
+	ARM64_SHA256H2,
+	ARM64_SHA256SU0,
+	ARM64_SHA256SU1,
+	ARM64_SHA512H,
+	ARM64_SHA512H2,
+	ARM64_SHA512SU0,
+	ARM64_SHA512SU1,
+	ARM64_SHADD,
+	ARM64_SHL,
+	ARM64_SHLL,
+	ARM64_SHLL2,
+	ARM64_SHRN,
+	ARM64_SHRN2,
+	ARM64_SHRNB,
+	ARM64_SHRNT,
+	ARM64_SHSUB,
+	ARM64_SHSUBR,
+	ARM64_SLI,
+	ARM64_SM3PARTW1,
+	ARM64_SM3PARTW2,
+	ARM64_SM3SS1,
+	ARM64_SM3TT1A,
+	ARM64_SM3TT1B,
+	ARM64_SM3TT2A,
+	ARM64_SM3TT2B,
+	ARM64_SM4E,
+	ARM64_SM4EKEY,
+	ARM64_SMADDL,
+	ARM64_SMAX,
+	ARM64_SMAXP,
+	ARM64_SMAXQV,
+	ARM64_SMAXV,
+	ARM64_SMC,
+	ARM64_SMIN,
+	ARM64_SMINP,
+	ARM64_SMINQV,
+	ARM64_SMINV,
+	ARM64_SMLAL,
+	ARM64_SMLAL2,
+	ARM64_SMLALB,
+	ARM64_SMLALL,
+	ARM64_SMLALT,
+	ARM64_SMLSL,
+	ARM64_SMLSL2,
+	ARM64_SMLSLB,
+	ARM64_SMLSLL,
+	ARM64_SMLSLT,
+	ARM64_SMMLA,
+	ARM64_SMNEGL,
+	ARM64_SMOP4A,
+	ARM64_SMOP4S,
+	ARM64_SMOPA,
+	ARM64_SMOPS,
+	ARM64_SMOV,
+	ARM64_SMSTART,
+	ARM64_SMSTOP,
+	ARM64_SMSUBL,
+	ARM64_SMULH,
+	ARM64_SMULL,
+	ARM64_SMULL2,
+	ARM64_SMULLB,
+	ARM64_SMULLT,
+	ARM64_SPLICE,
+	ARM64_SQABS,
+	ARM64_SQADD,
+	ARM64_SQCADD,
+	ARM64_SQCVT,
+	ARM64_SQCVTN,
+	ARM64_SQCVTU,
+	ARM64_SQCVTUN,
+	ARM64_SQDECB,
+	ARM64_SQDECD,
+	ARM64_SQDECH,
+	ARM64_SQDECP,
+	ARM64_SQDECW,
+	ARM64_SQDMLAL,
+	ARM64_SQDMLAL2,
+	ARM64_SQDMLALB,
+	ARM64_SQDMLALBT,
+	ARM64_SQDMLALT,
+	ARM64_SQDMLSL,
+	ARM64_SQDMLSL2,
+	ARM64_SQDMLSLB,
+	ARM64_SQDMLSLBT,
+	ARM64_SQDMLSLT,
+	ARM64_SQDMULH,
+	ARM64_SQDMULL,
+	ARM64_SQDMULL2,
+	ARM64_SQDMULLB,
+	ARM64_SQDMULLT,
+	ARM64_SQINCB,
+	ARM64_SQINCD,
+	ARM64_SQINCH,
+	ARM64_SQINCP,
+	ARM64_SQINCW,
+	ARM64_SQNEG,
+	ARM64_SQRDCMLAH,
+	ARM64_SQRDMLAH,
+	ARM64_SQRDMLSH,
+	ARM64_SQRDMULH,
+	ARM64_SQRSHL,
+	ARM64_SQRSHLR,
+	ARM64_SQRSHR,
+	ARM64_SQRSHRN,
+	ARM64_SQRSHRN2,
+	ARM64_SQRSHRNB,
+	ARM64_SQRSHRNT,
+	ARM64_SQRSHRU,
+	ARM64_SQRSHRUN,
+	ARM64_SQRSHRUN2,
+	ARM64_SQRSHRUNB,
+	ARM64_SQRSHRUNT,
+	ARM64_SQSHL,
+	ARM64_SQSHLR,
+	ARM64_SQSHLU,
+	ARM64_SQSHRN,
+	ARM64_SQSHRN2,
+	ARM64_SQSHRNB,
+	ARM64_SQSHRNT,
+	ARM64_SQSHRUN,
+	ARM64_SQSHRUN2,
+	ARM64_SQSHRUNB,
+	ARM64_SQSHRUNT,
+	ARM64_SQSUB,
+	ARM64_SQSUBR,
+	ARM64_SQXTN,
+	ARM64_SQXTN2,
+	ARM64_SQXTNB,
+	ARM64_SQXTNT,
+	ARM64_SQXTUN,
+	ARM64_SQXTUN2,
+	ARM64_SQXTUNB,
+	ARM64_SQXTUNT,
+	ARM64_SRHADD,
+	ARM64_SRI,
+	ARM64_SRSHL,
+	ARM64_SRSHLR,
+	ARM64_SRSHR,
+	ARM64_SRSRA,
+	ARM64_SSBB,
+	ARM64_SSHL,
+	ARM64_SSHLL,
+	ARM64_SSHLL2,
+	ARM64_SSHLLB,
+	ARM64_SSHLLT,
+	ARM64_SSHR,
+	ARM64_SSRA,
+	ARM64_SSUBL,
+	ARM64_SSUBL2,
+	ARM64_SSUBLB,
+	ARM64_SSUBLBT,
+	ARM64_SSUBLT,
+	ARM64_SSUBLTB,
+	ARM64_SSUBW,
+	ARM64_SSUBW2,
+	ARM64_SSUBWB,
+	ARM64_SSUBWT,
+	ARM64_ST1,
+	ARM64_ST1B,
+	ARM64_ST1D,
+	ARM64_ST1H,
+	ARM64_ST1Q,
+	ARM64_ST1W,
+	ARM64_ST2,
+	ARM64_ST2B,
+	ARM64_ST2D,
+	ARM64_ST2G,
+	ARM64_ST2H,
+	ARM64_ST2Q,
+	ARM64_ST2W,
+	ARM64_ST3,
+	ARM64_ST3B,
+	ARM64_ST3D,
+	ARM64_ST3H,
+	ARM64_ST3Q,
+	ARM64_ST3W,
+	ARM64_ST4,
+	ARM64_ST4B,
+	ARM64_ST4D,
+	ARM64_ST4H,
+	ARM64_ST4Q,
+	ARM64_ST4W,
+	ARM64_ST64B,
+	ARM64_ST64BV,
+	ARM64_ST64BV0,
+	ARM64_STADD,
+	ARM64_STADDB,
+	ARM64_STADDH,
+	ARM64_STADDL,
+	ARM64_STADDLB,
+	ARM64_STADDLH,
+	ARM64_STBFADD,
+	ARM64_STBFADDL,
+	ARM64_STBFMAX,
+	ARM64_STBFMAXL,
+	ARM64_STBFMAXNM,
+	ARM64_STBFMAXNML,
+	ARM64_STBFMIN,
+	ARM64_STBFMINL,
+	ARM64_STBFMINNM,
+	ARM64_STBFMINNML,
+	ARM64_STCLR,
+	ARM64_STCLRB,
+	ARM64_STCLRH,
+	ARM64_STCLRL,
+	ARM64_STCLRLB,
+	ARM64_STCLRLH,
+	ARM64_STEOR,
+	ARM64_STEORB,
+	ARM64_STEORH,
+	ARM64_STEORL,
+	ARM64_STEORLB,
+	ARM64_STEORLH,
+	ARM64_STFADD,
+	ARM64_STFADDL,
+	ARM64_STFMAX,
+	ARM64_STFMAXL,
+	ARM64_STFMAXNM,
+	ARM64_STFMAXNML,
+	ARM64_STFMIN,
+	ARM64_STFMINL,
+	ARM64_STFMINNM,
+	ARM64_STFMINNML,
+	ARM64_STG,
+	ARM64_STGM,
+	ARM64_STGP,
+	ARM64_STILP,
+	ARM64_STL1,
+	ARM64_STLLR,
+	ARM64_STLLRB,
+	ARM64_STLLRH,
+	ARM64_STLR,
+	ARM64_STLRB,
+	ARM64_STLRH,
+	ARM64_STLTXR,
+	ARM64_STLUR,
+	ARM64_STLURB,
+	ARM64_STLURH,
+	ARM64_STLXP,
+	ARM64_STLXR,
+	ARM64_STLXRB,
+	ARM64_STLXRH,
+	ARM64_STMOPA,
+	ARM64_STNP,
+	ARM64_STNT1B,
+	ARM64_STNT1D,
+	ARM64_STNT1H,
+	ARM64_STNT1W,
+	ARM64_STP,
+	ARM64_STR,
+	ARM64_STRB,
+	ARM64_STRH,
+	ARM64_STSET,
+	ARM64_STSETB,
+	ARM64_STSETH,
+	ARM64_STSETL,
+	ARM64_STSETLB,
+	ARM64_STSETLH,
+	ARM64_STSHH,
+	ARM64_STSMAX,
+	ARM64_STSMAXB,
+	ARM64_STSMAXH,
+	ARM64_STSMAXL,
+	ARM64_STSMAXLB,
+	ARM64_STSMAXLH,
+	ARM64_STSMIN,
+	ARM64_STSMINB,
+	ARM64_STSMINH,
+	ARM64_STSMINL,
+	ARM64_STSMINLB,
+	ARM64_STSMINLH,
+	ARM64_STTADD,
+	ARM64_STTADDL,
+	ARM64_STTCLR,
+	ARM64_STTCLRL,
+	ARM64_STTNP,
+	ARM64_STTP,
+	ARM64_STTR,
+	ARM64_STTRB,
+	ARM64_STTRH,
+	ARM64_STTSET,
+	ARM64_STTSETL,
+	ARM64_STTXR,
+	ARM64_STUMAX,
+	ARM64_STUMAXB,
+	ARM64_STUMAXH,
+	ARM64_STUMAXL,
+	ARM64_STUMAXLB,
+	ARM64_STUMAXLH,
+	ARM64_STUMIN,
+	ARM64_STUMINB,
+	ARM64_STUMINH,
+	ARM64_STUMINL,
+	ARM64_STUMINLB,
+	ARM64_STUMINLH,
+	ARM64_STUR,
+	ARM64_STURB,
+	ARM64_STURH,
+	ARM64_STXP,
+	ARM64_STXR,
+	ARM64_STXRB,
+	ARM64_STXRH,
+	ARM64_STZ2G,
+	ARM64_STZG,
+	ARM64_STZGM,
+	ARM64_SUB,
+	ARM64_SUBG,
+	ARM64_SUBHN,
+	ARM64_SUBHN2,
+	ARM64_SUBHNB,
+	ARM64_SUBHNT,
+	ARM64_SUBP,
+	ARM64_SUBPS,
+	ARM64_SUBPT,
+	ARM64_SUBR,
+	ARM64_SUBS,
+	ARM64_SUDOT,
+	ARM64_SUMLALL,
+	ARM64_SUMOP4A,
+	ARM64_SUMOP4S,
+	ARM64_SUMOPA,
+	ARM64_SUMOPS,
+	ARM64_SUNPK,
+	ARM64_SUNPKHI,
+	ARM64_SUNPKLO,
+	ARM64_SUQADD,
+	ARM64_SUTMOPA,
+	ARM64_SUVDOT,
+	ARM64_SVC,
+	ARM64_SVDOT,
+	ARM64_SWP,
+	ARM64_SWPA,
+	ARM64_SWPAB,
+	ARM64_SWPAH,
+	ARM64_SWPAL,
+	ARM64_SWPALB,
+	ARM64_SWPALH,
+	ARM64_SWPB,
+	ARM64_SWPH,
+	ARM64_SWPL,
+	ARM64_SWPLB,
+	ARM64_SWPLH,
+	ARM64_SWPP,
+	ARM64_SWPPA,
+	ARM64_SWPPAL,
+	ARM64_SWPPL,
+	ARM64_SWPT,
+	ARM64_SWPTA,
+	ARM64_SWPTAL,
+	ARM64_SWPTL,
+	ARM64_SXTB,
+	ARM64_SXTH,
+	ARM64_SXTL,
+	ARM64_SXTL2,
+	ARM64_SXTW,
+	ARM64_SYS,
+	ARM64_SYSL,
+	ARM64_SYSP,
+	ARM64_TBL,
+	ARM64_TBLQ,
+	ARM64_TBNZ,
+	ARM64_TBX,
+	ARM64_TBXQ,
+	ARM64_TBZ,
+	ARM64_TCANCEL,
+	ARM64_TCOMMIT,
+	ARM64_TLBI,
+	ARM64_TLBIP,
+	ARM64_TRCIT,
+	ARM64_TRN1,
+	ARM64_TRN2,
+	ARM64_TSB,
+	ARM64_TST,
+	ARM64_TSTART,
+	ARM64_TTEST,
+	ARM64_UABA,
+	ARM64_UABAL,
+	ARM64_UABAL2,
+	ARM64_UABALB,
+	ARM64_UABALT,
+	ARM64_UABD,
+	ARM64_UABDL,
+	ARM64_UABDL2,
+	ARM64_UABDLB,
+	ARM64_UABDLT,
+	ARM64_UADALP,
+	ARM64_UADDL,
+	ARM64_UADDL2,
+	ARM64_UADDLB,
+	ARM64_UADDLP,
+	ARM64_UADDLT,
+	ARM64_UADDLV,
+	ARM64_UADDV,
+	ARM64_UADDW,
+	ARM64_UADDW2,
+	ARM64_UADDWB,
+	ARM64_UADDWT,
+	ARM64_UBFIZ,
+	ARM64_UBFM,
+	ARM64_UBFX,
+	ARM64_UCLAMP,
+	ARM64_UCVTF,
+	ARM64_UDF,
+	ARM64_UDIV,
+	ARM64_UDIVR,
+	ARM64_UDOT,
+	ARM64_UHADD,
+	ARM64_UHSUB,
+	ARM64_UHSUBR,
+	ARM64_UMADDL,
+	ARM64_UMAX,
+	ARM64_UMAXP,
+	ARM64_UMAXQV,
+	ARM64_UMAXV,
+	ARM64_UMIN,
+	ARM64_UMINP,
+	ARM64_UMINQV,
+	ARM64_UMINV,
+	ARM64_UMLAL,
+	ARM64_UMLAL2,
+	ARM64_UMLALB,
+	ARM64_UMLALL,
+	ARM64_UMLALT,
+	ARM64_UMLSL,
+	ARM64_UMLSL2,
+	ARM64_UMLSLB,
+	ARM64_UMLSLL,
+	ARM64_UMLSLT,
+	ARM64_UMMLA,
+	ARM64_UMNEGL,
+	ARM64_UMOP4A,
+	ARM64_UMOP4S,
+	ARM64_UMOPA,
+	ARM64_UMOPS,
+	ARM64_UMOV,
+	ARM64_UMSUBL,
+	ARM64_UMULH,
+	ARM64_UMULL,
+	ARM64_UMULL2,
+	ARM64_UMULLB,
+	ARM64_UMULLT,
+	ARM64_UQADD,
+	ARM64_UQCVT,
+	ARM64_UQCVTN,
+	ARM64_UQDECB,
+	ARM64_UQDECD,
+	ARM64_UQDECH,
+	ARM64_UQDECP,
+	ARM64_UQDECW,
+	ARM64_UQINCB,
+	ARM64_UQINCD,
+	ARM64_UQINCH,
+	ARM64_UQINCP,
+	ARM64_UQINCW,
+	ARM64_UQRSHL,
+	ARM64_UQRSHLR,
+	ARM64_UQRSHR,
+	ARM64_UQRSHRN,
+	ARM64_UQRSHRN2,
+	ARM64_UQRSHRNB,
+	ARM64_UQRSHRNT,
+	ARM64_UQSHL,
+	ARM64_UQSHLR,
+	ARM64_UQSHRN,
+	ARM64_UQSHRN2,
+	ARM64_UQSHRNB,
+	ARM64_UQSHRNT,
+	ARM64_UQSUB,
+	ARM64_UQSUBR,
+	ARM64_UQXTN,
+	ARM64_UQXTN2,
+	ARM64_UQXTNB,
+	ARM64_UQXTNT,
+	ARM64_URECPE,
+	ARM64_URHADD,
+	ARM64_URSHL,
+	ARM64_URSHLR,
+	ARM64_URSHR,
+	ARM64_URSQRTE,
+	ARM64_URSRA,
+	ARM64_USDOT,
+	ARM64_USHL,
+	ARM64_USHLL,
+	ARM64_USHLL2,
+	ARM64_USHLLB,
+	ARM64_USHLLT,
+	ARM64_USHR,
+	ARM64_USMLALL,
+	ARM64_USMMLA,
+	ARM64_USMOP4A,
+	ARM64_USMOP4S,
+	ARM64_USMOPA,
+	ARM64_USMOPS,
+	ARM64_USQADD,
+	ARM64_USRA,
+	ARM64_USTMOPA,
+	ARM64_USUBL,
+	ARM64_USUBL2,
+	ARM64_USUBLB,
+	ARM64_USUBLT,
+	ARM64_USUBW,
+	ARM64_USUBW2,
+	ARM64_USUBWB,
+	ARM64_USUBWT,
+	ARM64_USVDOT,
+	ARM64_UTMOPA,
+	ARM64_UUNPK,
+	ARM64_UUNPKHI,
+	ARM64_UUNPKLO,
+	ARM64_UVDOT,
+	ARM64_UXTB,
+	ARM64_UXTH,
+	ARM64_UXTL,
+	ARM64_UXTL2,
+	ARM64_UXTW,
+	ARM64_UZP,
+	ARM64_UZP1,
+	ARM64_UZP2,
+	ARM64_UZPQ1,
+	ARM64_UZPQ2,
+	ARM64_WFE,
+	ARM64_WFET,
+	ARM64_WFI,
+	ARM64_WFIT,
+	ARM64_WHILEGE,
+	ARM64_WHILEGT,
+	ARM64_WHILEHI,
+	ARM64_WHILEHS,
+	ARM64_WHILELE,
+	ARM64_WHILELO,
+	ARM64_WHILELS,
+	ARM64_WHILELT,
+	ARM64_WHILERW,
+	ARM64_WHILEWR,
+	ARM64_WRFFR,
+	ARM64_XAFLAG,
+	ARM64_XAR,
+	ARM64_XPACD,
+	ARM64_XPACI,
+	ARM64_XPACLRI,
+	ARM64_XTN,
+	ARM64_XTN2,
+	ARM64_YIELD,
+	ARM64_ZERO,
+	ARM64_ZIP,
+	ARM64_ZIP1,
+	ARM64_ZIP2,
+	ARM64_ZIPQ1,
+	ARM64_ZIPQ2,
 };
 const char *operation_to_str(enum Operation oper);