#ifdef IROP_DISPATCH_DEFS
DEF_OP(GuestOpcode);
DEF_OP(ValidateCode);
DEF_OP(ThreadRemoveCodeEntry);
DEF_OP(ProcessorID);
DEF_OP(GetRoundingMode);
DEF_OP(SetRoundingMode);
DEF_OP(PushRoundingMode);
DEF_OP(PopRoundingMode);
DEF_OP(Print);
DEF_OP(PrintMsg);
DEF_OP(RDRAND);
DEF_OP(Yield);
DEF_OP(WFET);
DEF_OP(MonoBackpatcherWrite);
DEF_OP(Jump);
DEF_OP(CondJump);
DEF_OP(ExitFunction);
DEF_OP(Break);
DEF_OP(CallbackReturn);
DEF_OP(Syscall);
DEF_OP(Thunk);
DEF_OP(CPUID);
DEF_OP(XGetBV);
DEF_OP(Copy);
DEF_OP(LoadRegister);
DEF_OP(LoadPF);
DEF_OP(LoadAF);
DEF_OP(StoreRegister);
DEF_OP(StorePF);
DEF_OP(StoreAF);
DEF_OP(LoadContext);
DEF_OP(LoadContextPair);
DEF_OP(StoreContext);
DEF_OP(StoreContextPair);
DEF_OP(LoadContextIndexed);
DEF_OP(StoreContextIndexed);
DEF_OP(FormContextAddress);
DEF_OP(SpillRegister);
DEF_OP(FillRegister);
DEF_OP(LoadNZCV);
DEF_OP(StoreNZCV);
DEF_OP(LoadDF);
DEF_OP(LoadMem);
DEF_OP(LoadMemPair);
DEF_OP(StoreMem);
DEF_OP(StoreMemPair);
DEF_OP(StoreMemX87SVEOptPredicate);
DEF_OP(LoadMemX87SVEOptPredicate);
DEF_OP(LoadMemTSO);
DEF_OP(StoreMemTSO);
DEF_OP(VLoadVectorMasked);
DEF_OP(VStoreVectorMasked);
DEF_OP(VLoadVectorGatherMasked);
DEF_OP(VLoadVectorGatherMaskedQPS);
DEF_OP(VLoadVectorElement);
DEF_OP(VStoreVectorElement);
DEF_OP(VBroadcastFromMem);
DEF_OP(Push);
DEF_OP(PushTwo);
DEF_OP(RMWHandle);
DEF_OP(Pop);
DEF_OP(PopTwo);
DEF_OP(MemSet);
DEF_OP(MemCpy);
DEF_OP(CacheLineClear);
DEF_OP(CacheLineClean);
DEF_OP(CacheLineZero);
DEF_OP(Fence);
DEF_OP(Prefetch);
DEF_OP(VStoreNonTemporal);
DEF_OP(VStoreNonTemporalPair);
DEF_OP(VLoadNonTemporal);
DEF_OP(ContextClear);
DEF_OP(CAS);
DEF_OP(CASPair);
DEF_OP(AtomicSwap);
DEF_OP(AtomicFetchAdd);
DEF_OP(AtomicFetchSub);
DEF_OP(AtomicFetchAnd);
DEF_OP(AtomicFetchCLR);
DEF_OP(AtomicFetchOr);
DEF_OP(AtomicFetchXor);
DEF_OP(AtomicFetchNeg);
DEF_OP(TelemetrySetValue);
DEF_OP(EntrypointOffset);
DEF_OP(InlineEntrypointOffset);
DEF_OP(Constant);
DEF_OP(InlineConstant);
DEF_OP(CycleCounter);
DEF_OP(Neg);
DEF_OP(Not);
DEF_OP(Popcount);
DEF_OP(FindLSB);
DEF_OP(FindMSB);
DEF_OP(FindTrailingZeroes);
DEF_OP(CountLeadingZeroes);
DEF_OP(Rev);
DEF_OP(Rbit);
DEF_OP(Add);
DEF_OP(Adc);
DEF_OP(Sbb);
DEF_OP(AddShift);
DEF_OP(AddWithFlags);
DEF_OP(AddNZCV);
DEF_OP(SetSmallNZV);
DEF_OP(CarryInvert);
DEF_OP(AXFlag);
DEF_OP(Parity);
DEF_OP(RmifNZCV);
DEF_OP(CondAddNZCV);
DEF_OP(CondSubNZCV);
DEF_OP(AdcWithFlags);
DEF_OP(AdcZero);
DEF_OP(AdcZeroWithFlags);
DEF_OP(SbbWithFlags);
DEF_OP(AdcNZCV);
DEF_OP(SbbNZCV);
DEF_OP(Sub);
DEF_OP(SubShift);
DEF_OP(SubWithFlags);
DEF_OP(CmpPairZ);
DEF_OP(SubNZCV);
DEF_OP(Or);
DEF_OP(Orlshl);
DEF_OP(Orlshr);
DEF_OP(Ornror);
DEF_OP(Xor);
DEF_OP(XorShift);
DEF_OP(XornShift);
DEF_OP(And);
DEF_OP(AndShift);
DEF_OP(AndWithFlags);
DEF_OP(Andn);
DEF_OP(TestNZ);
DEF_OP(TestZ);
DEF_OP(Lshl);
DEF_OP(Lshr);
DEF_OP(Ashr);
DEF_OP(ShiftFlags);
DEF_OP(RotateFlags);
DEF_OP(Ror);
DEF_OP(Mul);
DEF_OP(UMul);
DEF_OP(UMull);
DEF_OP(SMull);
DEF_OP(MulH);
DEF_OP(UMulH);
DEF_OP(Bfi);
DEF_OP(Bfxil);
DEF_OP(Bfe);
DEF_OP(Sbfe);
DEF_OP(NZCVSelect);
DEF_OP(NZCVSelectV);
DEF_OP(NZCVSelectIncrement);
DEF_OP(Select);
DEF_OP(MaskGenerateFromBitWidth);
DEF_OP(Extr);
DEF_OP(PDep);
DEF_OP(PExt);
DEF_OP(Div);
DEF_OP(UDiv);
DEF_OP(VExtractToGPR);
DEF_OP(Float_ToGPR_S);
DEF_OP(Float_ToGPR_ZS);
DEF_OP(FCmp);
DEF_OP(VFAddScalarInsert);
DEF_OP(VFSubScalarInsert);
DEF_OP(VFMulScalarInsert);
DEF_OP(VFDivScalarInsert);
DEF_OP(VFMinScalarInsert);
DEF_OP(VFMaxScalarInsert);
DEF_OP(VFSqrtScalarInsert);
DEF_OP(VFRSqrtScalarInsert);
DEF_OP(VFRecpScalarInsert);
DEF_OP(VFToFScalarInsert);
DEF_OP(VSToFVectorInsert);
DEF_OP(VSToFGPRInsert);
DEF_OP(VFToIScalarInsert);
DEF_OP(VFCMPScalarInsert);
DEF_OP(VFMLAScalarInsert);
DEF_OP(VFMLSScalarInsert);
DEF_OP(VFNMLAScalarInsert);
DEF_OP(VFNMLSScalarInsert);
DEF_OP(VFCopySign);
DEF_OP(VMov);
DEF_OP(VectorImm);
DEF_OP(LoadNamedVectorConstant);
DEF_OP(LoadNamedVectorIndexedConstant);
DEF_OP(VNeg);
DEF_OP(VNot);
DEF_OP(VAbs);
DEF_OP(VPopcount);
DEF_OP(VAddV);
DEF_OP(VUMinV);
DEF_OP(VUMaxV);
DEF_OP(VFAbs);
DEF_OP(VFNeg);
DEF_OP(VFRecp);
DEF_OP(VFRecpPrecision);
DEF_OP(VFSqrt);
DEF_OP(VFRSqrt);
DEF_OP(VFRSqrtPrecision);
DEF_OP(VCMPEQZ);
DEF_OP(VCMPGTZ);
DEF_OP(VCMPLTZ);
DEF_OP(VDupElement);
DEF_OP(VShlI);
DEF_OP(VUShrI);
DEF_OP(VUShraI);
DEF_OP(VSShrI);
DEF_OP(VUShrNI);
DEF_OP(VUShrNI2);
DEF_OP(VSXTL);
DEF_OP(VSXTL2);
DEF_OP(VSSHLL);
DEF_OP(VSSHLL2);
DEF_OP(VUXTL);
DEF_OP(VUXTL2);
DEF_OP(VSQXTN);
DEF_OP(VSQXTN2);
DEF_OP(VSQXTNPair);
DEF_OP(VSQXTUN);
DEF_OP(VSQXTUN2);
DEF_OP(VSQXTUNPair);
DEF_OP(VSRSHR);
DEF_OP(VSQSHL);
DEF_OP(VRev32);
DEF_OP(VRev64);
DEF_OP(VAdd);
DEF_OP(VSub);
DEF_OP(VAnd);
DEF_OP(VAndn);
DEF_OP(VOrn);
DEF_OP(VOr);
DEF_OP(VXor);
DEF_OP(VUQAdd);
DEF_OP(VUQSub);
DEF_OP(VSQAdd);
DEF_OP(VSQSub);
DEF_OP(VAddP);
DEF_OP(VURAvg);
DEF_OP(VUMin);
DEF_OP(VUMax);
DEF_OP(VSMin);
DEF_OP(VSMax);
DEF_OP(VZip);
DEF_OP(VZip2);
DEF_OP(VUnZip);
DEF_OP(VUnZip2);
DEF_OP(VTrn);
DEF_OP(VTrn2);
DEF_OP(VFAdd);
DEF_OP(VFAddP);
DEF_OP(VFAddV);
DEF_OP(VFSub);
DEF_OP(VFMul);
DEF_OP(VFDiv);
DEF_OP(VFMin);
DEF_OP(VFMax);
DEF_OP(VMul);
DEF_OP(VUMull);
DEF_OP(VSMull);
DEF_OP(VUMull2);
DEF_OP(VSMull2);
DEF_OP(VUMulH);
DEF_OP(VSMulH);
DEF_OP(VUABDL);
DEF_OP(VUABDL2);
DEF_OP(VUShl);
DEF_OP(VUShr);
DEF_OP(VSShr);
DEF_OP(VUShlS);
DEF_OP(VUShrS);
DEF_OP(VSShrS);
DEF_OP(VUShrSWide);
DEF_OP(VSShrSWide);
DEF_OP(VUShlSWide);
DEF_OP(VInsElement);
DEF_OP(VInsGPR);
DEF_OP(VExtr);
DEF_OP(VCMPEQ);
DEF_OP(VCMPGT);
DEF_OP(VFCMPEQ);
DEF_OP(VFCMPNEQ);
DEF_OP(VFCMPLT);
DEF_OP(VFCMPGT);
DEF_OP(VFCMPLE);
DEF_OP(VFCMPORD);
DEF_OP(VFCMPUNO);
DEF_OP(VTBL1);
DEF_OP(VTBL2);
DEF_OP(VTBX1);
DEF_OP(VBSL);
DEF_OP(VFCADD);
DEF_OP(VFMLA);
DEF_OP(VFMLS);
DEF_OP(VFNMLA);
DEF_OP(VFNMLS);
DEF_OP(VCastFromGPR);
DEF_OP(VDupFromGPR);
DEF_OP(VLoadTwoGPRs);
DEF_OP(Float_FromGPR_S);
DEF_OP(Float_FToF);
DEF_OP(Vector_SToF);
DEF_OP(Vector_FToS);
DEF_OP(Vector_FToZS);
DEF_OP(Vector_FToF);
DEF_OP(VFCVTL2);
DEF_OP(VFCVTN2);
DEF_OP(Vector_FToI);
DEF_OP(Vector_FToISized);
DEF_OP(Vector_F64ToI32);
DEF_OP(VAESImc);
DEF_OP(VAESEnc);
DEF_OP(VAESEncLast);
DEF_OP(VAESDec);
DEF_OP(VAESDecLast);
DEF_OP(VAESKeyGenAssist);
DEF_OP(VSha1H);
DEF_OP(VSha1C);
DEF_OP(VSha1M);
DEF_OP(VSha1P);
DEF_OP(VSha1SU1);
DEF_OP(VSha256U0);
DEF_OP(VSha256U1);
DEF_OP(VSha256H);
DEF_OP(VSha256H2);
DEF_OP(CRC32);
DEF_OP(PCLMUL);
DEF_OP(F64TAN);
DEF_OP(F64SIN);
DEF_OP(F64COS);
#undef IROP_DISPATCH_DEFS
#endif
#ifdef IROP_DISPATCH_DISPATCH
REGISTER_OP(DUMMY, NoOp);
REGISTER_OP(IRHEADER, NoOp);
REGISTER_OP(CODEBLOCK, NoOp);
REGISTER_OP(BEGINBLOCK, NoOp);
REGISTER_OP(INVALIDATEFLAGS, NoOp);
REGISTER_OP(ENDBLOCK, NoOp);
REGISTER_OP(GUESTOPCODE, GuestOpcode);
REGISTER_OP(VALIDATECODE, ValidateCode);
REGISTER_OP(THREADREMOVECODEENTRY, ThreadRemoveCodeEntry);
REGISTER_OP(PROCESSORID, ProcessorID);
REGISTER_OP(GETROUNDINGMODE, GetRoundingMode);
REGISTER_OP(SETROUNDINGMODE, SetRoundingMode);
REGISTER_OP(PUSHROUNDINGMODE, PushRoundingMode);
REGISTER_OP(POPROUNDINGMODE, PopRoundingMode);
REGISTER_OP(PRINT, Print);
REGISTER_OP(PRINTMSG, PrintMsg);
REGISTER_OP(RDRAND, RDRAND);
REGISTER_OP(YIELD, Yield);
REGISTER_OP(WFET, WFET);
REGISTER_OP(MONOBACKPATCHERWRITE, MonoBackpatcherWrite);
REGISTER_OP(JUMP, Jump);
REGISTER_OP(CONDJUMP, CondJump);
REGISTER_OP(EXITFUNCTION, ExitFunction);
REGISTER_OP(BREAK, Break);
REGISTER_OP(CALLBACKRETURN, CallbackReturn);
REGISTER_OP(SYSCALL, Syscall);
REGISTER_OP(THUNK, Thunk);
REGISTER_OP(CPUID, CPUID);
REGISTER_OP(XGETBV, XGetBV);
REGISTER_OP(COPY, Copy);
REGISTER_OP(LOADREGISTER, LoadRegister);
REGISTER_OP(LOADPF, LoadPF);
REGISTER_OP(LOADAF, LoadAF);
REGISTER_OP(STOREREGISTER, StoreRegister);
REGISTER_OP(STOREPF, StorePF);
REGISTER_OP(STOREAF, StoreAF);
REGISTER_OP(LOADCONTEXT, LoadContext);
REGISTER_OP(LOADCONTEXTPAIR, LoadContextPair);
REGISTER_OP(STORECONTEXT, StoreContext);
REGISTER_OP(STORECONTEXTPAIR, StoreContextPair);
REGISTER_OP(LOADCONTEXTINDEXED, LoadContextIndexed);
REGISTER_OP(STORECONTEXTINDEXED, StoreContextIndexed);
REGISTER_OP(FORMCONTEXTADDRESS, FormContextAddress);
REGISTER_OP(SPILLREGISTER, SpillRegister);
REGISTER_OP(FILLREGISTER, FillRegister);
REGISTER_OP(LOADNZCV, LoadNZCV);
REGISTER_OP(STORENZCV, StoreNZCV);
REGISTER_OP(LOADDF, LoadDF);
REGISTER_OP(LOADMEM, LoadMem);
REGISTER_OP(LOADMEMPAIR, LoadMemPair);
REGISTER_OP(STOREMEM, StoreMem);
REGISTER_OP(STOREMEMPAIR, StoreMemPair);
REGISTER_OP(STOREMEMX87SVEOPTPREDICATE, StoreMemX87SVEOptPredicate);
REGISTER_OP(LOADMEMX87SVEOPTPREDICATE, LoadMemX87SVEOptPredicate);
REGISTER_OP(LOADMEMTSO, LoadMemTSO);
REGISTER_OP(STOREMEMTSO, StoreMemTSO);
REGISTER_OP(VLOADVECTORMASKED, VLoadVectorMasked);
REGISTER_OP(VSTOREVECTORMASKED, VStoreVectorMasked);
REGISTER_OP(VLOADVECTORGATHERMASKED, VLoadVectorGatherMasked);
REGISTER_OP(VLOADVECTORGATHERMASKEDQPS, VLoadVectorGatherMaskedQPS);
REGISTER_OP(VLOADVECTORELEMENT, VLoadVectorElement);
REGISTER_OP(VSTOREVECTORELEMENT, VStoreVectorElement);
REGISTER_OP(VBROADCASTFROMMEM, VBroadcastFromMem);
REGISTER_OP(PUSH, Push);
REGISTER_OP(PUSHTWO, PushTwo);
REGISTER_OP(RMWHANDLE, RMWHandle);
REGISTER_OP(POP, Pop);
REGISTER_OP(POPTWO, PopTwo);
REGISTER_OP(MEMSET, MemSet);
REGISTER_OP(MEMCPY, MemCpy);
REGISTER_OP(CACHELINECLEAR, CacheLineClear);
REGISTER_OP(CACHELINECLEAN, CacheLineClean);
REGISTER_OP(CACHELINEZERO, CacheLineZero);
REGISTER_OP(FENCE, Fence);
REGISTER_OP(PREFETCH, Prefetch);
REGISTER_OP(VSTORENONTEMPORAL, VStoreNonTemporal);
REGISTER_OP(VSTORENONTEMPORALPAIR, VStoreNonTemporalPair);
REGISTER_OP(VLOADNONTEMPORAL, VLoadNonTemporal);
REGISTER_OP(CONTEXTCLEAR, ContextClear);
REGISTER_OP(CAS, CAS);
REGISTER_OP(CASPAIR, CASPair);
REGISTER_OP(ATOMICSWAP, AtomicSwap);
REGISTER_OP(ATOMICFETCHADD, AtomicFetchAdd);
REGISTER_OP(ATOMICFETCHSUB, AtomicFetchSub);
REGISTER_OP(ATOMICFETCHAND, AtomicFetchAnd);
REGISTER_OP(ATOMICFETCHCLR, AtomicFetchCLR);
REGISTER_OP(ATOMICFETCHOR, AtomicFetchOr);
REGISTER_OP(ATOMICFETCHXOR, AtomicFetchXor);
REGISTER_OP(ATOMICFETCHNEG, AtomicFetchNeg);
REGISTER_OP(TELEMETRYSETVALUE, TelemetrySetValue);
REGISTER_OP(ENTRYPOINTOFFSET, EntrypointOffset);
REGISTER_OP(INLINEENTRYPOINTOFFSET, InlineEntrypointOffset);
REGISTER_OP(CONSTANT, Constant);
REGISTER_OP(INLINECONSTANT, InlineConstant);
REGISTER_OP(CYCLECOUNTER, CycleCounter);
REGISTER_OP(NEG, Neg);
REGISTER_OP(NOT, Not);
REGISTER_OP(POPCOUNT, Popcount);
REGISTER_OP(FINDLSB, FindLSB);
REGISTER_OP(FINDMSB, FindMSB);
REGISTER_OP(FINDTRAILINGZEROES, FindTrailingZeroes);
REGISTER_OP(COUNTLEADINGZEROES, CountLeadingZeroes);
REGISTER_OP(REV, Rev);
REGISTER_OP(RBIT, Rbit);
REGISTER_OP(ADD, Add);
REGISTER_OP(ADC, Adc);
REGISTER_OP(SBB, Sbb);
REGISTER_OP(ADDSHIFT, AddShift);
REGISTER_OP(ADDWITHFLAGS, AddWithFlags);
REGISTER_OP(ADDNZCV, AddNZCV);
REGISTER_OP(SETSMALLNZV, SetSmallNZV);
REGISTER_OP(CARRYINVERT, CarryInvert);
REGISTER_OP(AXFLAG, AXFlag);
REGISTER_OP(PARITY, Parity);
REGISTER_OP(RMIFNZCV, RmifNZCV);
REGISTER_OP(CONDADDNZCV, CondAddNZCV);
REGISTER_OP(CONDSUBNZCV, CondSubNZCV);
REGISTER_OP(ADCWITHFLAGS, AdcWithFlags);
REGISTER_OP(ADCZERO, AdcZero);
REGISTER_OP(ADCZEROWITHFLAGS, AdcZeroWithFlags);
REGISTER_OP(SBBWITHFLAGS, SbbWithFlags);
REGISTER_OP(ADCNZCV, AdcNZCV);
REGISTER_OP(SBBNZCV, SbbNZCV);
REGISTER_OP(SUB, Sub);
REGISTER_OP(SUBSHIFT, SubShift);
REGISTER_OP(SUBWITHFLAGS, SubWithFlags);
REGISTER_OP(CMPPAIRZ, CmpPairZ);
REGISTER_OP(SUBNZCV, SubNZCV);
REGISTER_OP(OR, Or);
REGISTER_OP(ORLSHL, Orlshl);
REGISTER_OP(ORLSHR, Orlshr);
REGISTER_OP(ORNROR, Ornror);
REGISTER_OP(XOR, Xor);
REGISTER_OP(XORSHIFT, XorShift);
REGISTER_OP(XORNSHIFT, XornShift);
REGISTER_OP(AND, And);
REGISTER_OP(ANDSHIFT, AndShift);
REGISTER_OP(ANDWITHFLAGS, AndWithFlags);
REGISTER_OP(ANDN, Andn);
REGISTER_OP(TESTNZ, TestNZ);
REGISTER_OP(TESTZ, TestZ);
REGISTER_OP(LSHL, Lshl);
REGISTER_OP(LSHR, Lshr);
REGISTER_OP(ASHR, Ashr);
REGISTER_OP(SHIFTFLAGS, ShiftFlags);
REGISTER_OP(ROTATEFLAGS, RotateFlags);
REGISTER_OP(ROR, Ror);
REGISTER_OP(MUL, Mul);
REGISTER_OP(UMUL, UMul);
REGISTER_OP(UMULL, UMull);
REGISTER_OP(SMULL, SMull);
REGISTER_OP(MULH, MulH);
REGISTER_OP(UMULH, UMulH);
REGISTER_OP(BFI, Bfi);
REGISTER_OP(BFXIL, Bfxil);
REGISTER_OP(BFE, Bfe);
REGISTER_OP(SBFE, Sbfe);
REGISTER_OP(NZCVSELECT, NZCVSelect);
REGISTER_OP(NZCVSELECTV, NZCVSelectV);
REGISTER_OP(NZCVSELECTINCREMENT, NZCVSelectIncrement);
REGISTER_OP(SELECT, Select);
REGISTER_OP(MASKGENERATEFROMBITWIDTH, MaskGenerateFromBitWidth);
REGISTER_OP(EXTR, Extr);
REGISTER_OP(PDEP, PDep);
REGISTER_OP(PEXT, PExt);
REGISTER_OP(DIV, Div);
REGISTER_OP(UDIV, UDiv);
REGISTER_OP(VEXTRACTTOGPR, VExtractToGPR);
REGISTER_OP(FLOAT_TOGPR_S, Float_ToGPR_S);
REGISTER_OP(FLOAT_TOGPR_ZS, Float_ToGPR_ZS);
REGISTER_OP(FCMP, FCmp);
REGISTER_OP(VFADDSCALARINSERT, VFAddScalarInsert);
REGISTER_OP(VFSUBSCALARINSERT, VFSubScalarInsert);
REGISTER_OP(VFMULSCALARINSERT, VFMulScalarInsert);
REGISTER_OP(VFDIVSCALARINSERT, VFDivScalarInsert);
REGISTER_OP(VFMINSCALARINSERT, VFMinScalarInsert);
REGISTER_OP(VFMAXSCALARINSERT, VFMaxScalarInsert);
REGISTER_OP(VFSQRTSCALARINSERT, VFSqrtScalarInsert);
REGISTER_OP(VFRSQRTSCALARINSERT, VFRSqrtScalarInsert);
REGISTER_OP(VFRECPSCALARINSERT, VFRecpScalarInsert);
REGISTER_OP(VFTOFSCALARINSERT, VFToFScalarInsert);
REGISTER_OP(VSTOFVECTORINSERT, VSToFVectorInsert);
REGISTER_OP(VSTOFGPRINSERT, VSToFGPRInsert);
REGISTER_OP(VFTOISCALARINSERT, VFToIScalarInsert);
REGISTER_OP(VFCMPSCALARINSERT, VFCMPScalarInsert);
REGISTER_OP(VFMLASCALARINSERT, VFMLAScalarInsert);
REGISTER_OP(VFMLSSCALARINSERT, VFMLSScalarInsert);
REGISTER_OP(VFNMLASCALARINSERT, VFNMLAScalarInsert);
REGISTER_OP(VFNMLSSCALARINSERT, VFNMLSScalarInsert);
REGISTER_OP(VFCOPYSIGN, VFCopySign);
REGISTER_OP(VMOV, VMov);
REGISTER_OP(VECTORIMM, VectorImm);
REGISTER_OP(LOADNAMEDVECTORCONSTANT, LoadNamedVectorConstant);
REGISTER_OP(LOADNAMEDVECTORINDEXEDCONSTANT, LoadNamedVectorIndexedConstant);
REGISTER_OP(VNEG, VNeg);
REGISTER_OP(VNOT, VNot);
REGISTER_OP(VABS, VAbs);
REGISTER_OP(VPOPCOUNT, VPopcount);
REGISTER_OP(VADDV, VAddV);
REGISTER_OP(VUMINV, VUMinV);
REGISTER_OP(VUMAXV, VUMaxV);
REGISTER_OP(VFABS, VFAbs);
REGISTER_OP(VFNEG, VFNeg);
REGISTER_OP(VFRECP, VFRecp);
REGISTER_OP(VFRECPPRECISION, VFRecpPrecision);
REGISTER_OP(VFSQRT, VFSqrt);
REGISTER_OP(VFRSQRT, VFRSqrt);
REGISTER_OP(VFRSQRTPRECISION, VFRSqrtPrecision);
REGISTER_OP(VCMPEQZ, VCMPEQZ);
REGISTER_OP(VCMPGTZ, VCMPGTZ);
REGISTER_OP(VCMPLTZ, VCMPLTZ);
REGISTER_OP(VDUPELEMENT, VDupElement);
REGISTER_OP(VSHLI, VShlI);
REGISTER_OP(VUSHRI, VUShrI);
REGISTER_OP(VUSHRAI, VUShraI);
REGISTER_OP(VSSHRI, VSShrI);
REGISTER_OP(VUSHRNI, VUShrNI);
REGISTER_OP(VUSHRNI2, VUShrNI2);
REGISTER_OP(VSXTL, VSXTL);
REGISTER_OP(VSXTL2, VSXTL2);
REGISTER_OP(VSSHLL, VSSHLL);
REGISTER_OP(VSSHLL2, VSSHLL2);
REGISTER_OP(VUXTL, VUXTL);
REGISTER_OP(VUXTL2, VUXTL2);
REGISTER_OP(VSQXTN, VSQXTN);
REGISTER_OP(VSQXTN2, VSQXTN2);
REGISTER_OP(VSQXTNPAIR, VSQXTNPair);
REGISTER_OP(VSQXTUN, VSQXTUN);
REGISTER_OP(VSQXTUN2, VSQXTUN2);
REGISTER_OP(VSQXTUNPAIR, VSQXTUNPair);
REGISTER_OP(VSRSHR, VSRSHR);
REGISTER_OP(VSQSHL, VSQSHL);
REGISTER_OP(VREV32, VRev32);
REGISTER_OP(VREV64, VRev64);
REGISTER_OP(VADD, VAdd);
REGISTER_OP(VSUB, VSub);
REGISTER_OP(VAND, VAnd);
REGISTER_OP(VANDN, VAndn);
REGISTER_OP(VORN, VOrn);
REGISTER_OP(VOR, VOr);
REGISTER_OP(VXOR, VXor);
REGISTER_OP(VUQADD, VUQAdd);
REGISTER_OP(VUQSUB, VUQSub);
REGISTER_OP(VSQADD, VSQAdd);
REGISTER_OP(VSQSUB, VSQSub);
REGISTER_OP(VADDP, VAddP);
REGISTER_OP(VURAVG, VURAvg);
REGISTER_OP(VUMIN, VUMin);
REGISTER_OP(VUMAX, VUMax);
REGISTER_OP(VSMIN, VSMin);
REGISTER_OP(VSMAX, VSMax);
REGISTER_OP(VZIP, VZip);
REGISTER_OP(VZIP2, VZip2);
REGISTER_OP(VUNZIP, VUnZip);
REGISTER_OP(VUNZIP2, VUnZip2);
REGISTER_OP(VTRN, VTrn);
REGISTER_OP(VTRN2, VTrn2);
REGISTER_OP(VFADD, VFAdd);
REGISTER_OP(VFADDP, VFAddP);
REGISTER_OP(VFADDV, VFAddV);
REGISTER_OP(VFSUB, VFSub);
REGISTER_OP(VFMUL, VFMul);
REGISTER_OP(VFDIV, VFDiv);
REGISTER_OP(VFMIN, VFMin);
REGISTER_OP(VFMAX, VFMax);
REGISTER_OP(VMUL, VMul);
REGISTER_OP(VUMULL, VUMull);
REGISTER_OP(VSMULL, VSMull);
REGISTER_OP(VUMULL2, VUMull2);
REGISTER_OP(VSMULL2, VSMull2);
REGISTER_OP(VUMULH, VUMulH);
REGISTER_OP(VSMULH, VSMulH);
REGISTER_OP(VUABDL, VUABDL);
REGISTER_OP(VUABDL2, VUABDL2);
REGISTER_OP(VUSHL, VUShl);
REGISTER_OP(VUSHR, VUShr);
REGISTER_OP(VSSHR, VSShr);
REGISTER_OP(VUSHLS, VUShlS);
REGISTER_OP(VUSHRS, VUShrS);
REGISTER_OP(VSSHRS, VSShrS);
REGISTER_OP(VUSHRSWIDE, VUShrSWide);
REGISTER_OP(VSSHRSWIDE, VSShrSWide);
REGISTER_OP(VUSHLSWIDE, VUShlSWide);
REGISTER_OP(VINSELEMENT, VInsElement);
REGISTER_OP(VINSGPR, VInsGPR);
REGISTER_OP(VEXTR, VExtr);
REGISTER_OP(VCMPEQ, VCMPEQ);
REGISTER_OP(VCMPGT, VCMPGT);
REGISTER_OP(VFCMPEQ, VFCMPEQ);
REGISTER_OP(VFCMPNEQ, VFCMPNEQ);
REGISTER_OP(VFCMPLT, VFCMPLT);
REGISTER_OP(VFCMPGT, VFCMPGT);
REGISTER_OP(VFCMPLE, VFCMPLE);
REGISTER_OP(VFCMPORD, VFCMPORD);
REGISTER_OP(VFCMPUNO, VFCMPUNO);
REGISTER_OP(VTBL1, VTBL1);
REGISTER_OP(VTBL2, VTBL2);
REGISTER_OP(VTBX1, VTBX1);
REGISTER_OP(VBSL, VBSL);
REGISTER_OP(VFCADD, VFCADD);
REGISTER_OP(VFMLA, VFMLA);
REGISTER_OP(VFMLS, VFMLS);
REGISTER_OP(VFNMLA, VFNMLA);
REGISTER_OP(VFNMLS, VFNMLS);
REGISTER_OP(VCASTFROMGPR, VCastFromGPR);
REGISTER_OP(VDUPFROMGPR, VDupFromGPR);
REGISTER_OP(VLOADTWOGPRS, VLoadTwoGPRs);
REGISTER_OP(FLOAT_FROMGPR_S, Float_FromGPR_S);
REGISTER_OP(FLOAT_FTOF, Float_FToF);
REGISTER_OP(VECTOR_STOF, Vector_SToF);
REGISTER_OP(VECTOR_FTOS, Vector_FToS);
REGISTER_OP(VECTOR_FTOZS, Vector_FToZS);
REGISTER_OP(VECTOR_FTOF, Vector_FToF);
REGISTER_OP(VFCVTL2, VFCVTL2);
REGISTER_OP(VFCVTN2, VFCVTN2);
REGISTER_OP(VECTOR_FTOI, Vector_FToI);
REGISTER_OP(VECTOR_FTOISIZED, Vector_FToISized);
REGISTER_OP(VECTOR_F64TOI32, Vector_F64ToI32);
REGISTER_OP(VAESIMC, VAESImc);
REGISTER_OP(VAESENC, VAESEnc);
REGISTER_OP(VAESENCLAST, VAESEncLast);
REGISTER_OP(VAESDEC, VAESDec);
REGISTER_OP(VAESDECLAST, VAESDecLast);
REGISTER_OP(VAESKEYGENASSIST, VAESKeyGenAssist);
REGISTER_OP(VSHA1H, VSha1H);
REGISTER_OP(VSHA1C, VSha1C);
REGISTER_OP(VSHA1M, VSha1M);
REGISTER_OP(VSHA1P, VSha1P);
REGISTER_OP(VSHA1SU1, VSha1SU1);
REGISTER_OP(VSHA256U0, VSha256U0);
REGISTER_OP(VSHA256U1, VSha256U1);
REGISTER_OP(VSHA256H, VSha256H);
REGISTER_OP(VSHA256H2, VSha256H2);
REGISTER_OP(CRC32, CRC32);
REGISTER_OP(PCLMUL, PCLMUL);
REGISTER_OP(F64TAN, F64TAN);
REGISTER_OP(F64SIN, F64SIN);
REGISTER_OP(F64COS, F64COS);
#undef IROP_DISPATCH_DISPATCH
#endif
