// Copyright 2026 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package loong64

import (
	"cmd/internal/obj"
)

var oprrrr = map[obj.As]uint32{
	AFMADDF:  0x81 << 20,  // fmadd.s
	AFMADDD:  0x82 << 20,  // fmadd.d
	AFMSUBF:  0x85 << 20,  // fmsub.s
	AFMSUBD:  0x86 << 20,  // fmsub.d
	AFNMADDF: 0x89 << 20,  // fnmadd.f
	AFNMADDD: 0x8a << 20,  // fnmadd.d
	AFNMSUBF: 0x8d << 20,  // fnmsub.s
	AFNMSUBD: 0x8e << 20,  // fnmsub.d
	AVSHUFB:  0x0d5 << 20, // vshuf.b
	AXVSHUFB: 0x0d6 << 20, // xvshuf.b
}

var oprrr = map[obj.As]uint32{
	AADD:           0x20 << 15,          // add.w
	AADDW:          0x20 << 15,          // add.w
	AADDV:          0x21 << 15,          // add.d
	AADDVU:         0x21 << 15,          // add.d
	ASUB:           0x22 << 15,          // sub.w
	ASUBW:          0x22 << 15,          // sub.w
	ANEGW:          0x22 << 15,          // sub.w
	ASUBV:          0x23 << 15,          // sub.d
	ASUBVU:         0x23 << 15,          // sub.d
	ANEGV:          0x23 << 15,          // sub.d
	ASGT:           0x24 << 15,          // slt
	ASGTU:          0x25 << 15,          // sltu
	AMASKEQZ:       0x26 << 15,          // maskeqz
	AMASKNEZ:       0x27 << 15,          // masknez
	ASCQ:           0x070AE << 15,       // sc.q
	ANOR:           0x28 << 15,          // nor
	AAND:           0x29 << 15,          // and
	AOR:            0x2a << 15,          // or
	AXOR:           0x2b << 15,          // xor
	AORN:           0x2c << 15,          // orn
	AANDN:          0x2d << 15,          // andn
	ASLL:           0x2e << 15,          // sll.w
	ASRL:           0x2f << 15,          // srl.w
	ASRA:           0x30 << 15,          // sra.w
	ASLLV:          0x31 << 15,          // sll.d
	ASRLV:          0x32 << 15,          // srl.d
	ASRAV:          0x33 << 15,          // sra.d
	AROTR:          0x36 << 15,          // rotr.w
	AROTRV:         0x37 << 15,          // rotr.d
	AMUL:           0x38 << 15,          // mul.w
	AMULW:          0x38 << 15,          // mul.w
	AMULH:          0x39 << 15,          // mulh.w
	AMULHU:         0x3a << 15,          // mulhu.w
	AMULV:          0x3b << 15,          // mul.d
	AMULVU:         0x3b << 15,          // mul.d
	AMULHV:         0x3c << 15,          // mulh.d
	AMULHVU:        0x3d << 15,          // mulhu.d
	AMULWVW:        0x3e << 15,          // mulw.d.w
	AMULWVWU:       0x3f << 15,          // mulw.d.wu
	ADIV:           0x40 << 15,          // div.w
	ADIVW:          0x40 << 15,          // div.w
	AREM:           0x41 << 15,          // mod.w
	AREMW:          0x41 << 15,          // mod.w
	ADIVU:          0x42 << 15,          // div.wu
	ADIVWU:         0x42 << 15,          // div.wu
	AREMU:          0x43 << 15,          // mod.wu
	AREMWU:         0x43 << 15,          // mod.wu
	ADIVV:          0x44 << 15,          // div.d
	AREMV:          0x45 << 15,          // mod.d
	ADIVVU:         0x46 << 15,          // div.du
	AREMVU:         0x47 << 15,          // mod.du
	ACRCWBW:        0x48 << 15,          // crc.w.b.w
	ACRCWHW:        0x49 << 15,          // crc.w.h.w
	ACRCWWW:        0x4a << 15,          // crc.w.w.w
	ACRCWVW:        0x4b << 15,          // crc.w.d.w
	ACRCCWBW:       0x4c << 15,          // crcc.w.b.w
	ACRCCWHW:       0x4d << 15,          // crcc.w.h.w
	ACRCCWWW:       0x4e << 15,          // crcc.w.w.w
	ACRCCWVW:       0x4f << 15,          // crcc.w.d.w
	AJMP:           0x13 << 26,          // jirl r0, rj, 0
	AJAL:           0x13<<26 | 1<<0,     // jirl r1, rj, 0
	AMULF:          0x209 << 15,         // fmul.s
	AMULD:          0x20a << 15,         // fmul.d
	ADIVF:          0x20d << 15,         // fdiv.s
	ADIVD:          0x20e << 15,         // fdiv.d
	ASUBF:          0x205 << 15,         // fsub.s
	ASUBD:          0x206 << 15,         // fsub.d
	AADDF:          0x201 << 15,         // fadd.s
	AADDD:          0x202 << 15,         // fadd.d
	ACMPEQF:        0x0c1<<20 | 0x4<<15, // FCMP.CEQ.S
	ACMPEQD:        0x0c2<<20 | 0x4<<15, // FCMP.CEQ.D
	ACMPGED:        0x0c2<<20 | 0x7<<15, // FCMP.SLE.D
	ACMPGEF:        0x0c1<<20 | 0x7<<15, // FCMP.SLE.S
	ACMPGTD:        0x0c2<<20 | 0x3<<15, // FCMP.SLT.D
	ACMPGTF:        0x0c1<<20 | 0x3<<15, // FCMP.SLT.S
	AFMINF:         0x215 << 15,         // fmin.s
	AFMIND:         0x216 << 15,         // fmin.d
	AFMAXF:         0x211 << 15,         // fmax.s
	AFMAXD:         0x212 << 15,         // fmax.d
	AFMAXAF:        0x219 << 15,         // fmaxa.s
	AFMAXAD:        0x21a << 15,         // fmaxa.d
	AFMINAF:        0x21d << 15,         // fmina.s
	AFMINAD:        0x21e << 15,         // fmina.d
	AFSCALEBF:      0x221 << 15,         // fscaleb.s
	AFSCALEBD:      0x222 << 15,         // fscaleb.d
	AFCOPYSGF:      0x225 << 15,         // fcopysign.s
	AFCOPYSGD:      0x226 << 15,         // fcopysign.d
	-AMOVB:         0x07000 << 15,       // ldx.b
	-AMOVH:         0x07008 << 15,       // ldx.h
	-AMOVW:         0x07010 << 15,       // ldx.w
	-AMOVV:         0x07018 << 15,       // ldx.d
	-AMOVBU:        0x07040 << 15,       // ldx.bu
	-AMOVHU:        0x07048 << 15,       // ldx.hu
	-AMOVWU:        0x07050 << 15,       // ldx.wu
	AMOVB:          0x07020 << 15,       // stx.b
	AMOVH:          0x07028 << 15,       // stx.h
	AMOVW:          0x07030 << 15,       // stx.w
	AMOVV:          0x07038 << 15,       // stx.d
	-AMOVF:         0x07060 << 15,       // fldx.s
	-AMOVD:         0x07068 << 15,       // fldx.d
	AMOVF:          0x07070 << 15,       // fstx.s
	AMOVD:          0x07078 << 15,       // fstx.d
	-AVMOVQ:        0x07080 << 15,       // vldx
	-AXVMOVQ:       0x07090 << 15,       // xvldx
	AVMOVQ:         0x07088 << 15,       // vstx
	AXVMOVQ:        0x07098 << 15,       // xvstx
	AVSEQB:         0x0e000 << 15,       // vseq.b
	AXVSEQB:        0x0e800 << 15,       // xvseq.b
	AVSEQH:         0x0e001 << 15,       // vseq.h
	AXVSEQH:        0x0e801 << 15,       // xvseq.h
	AVSEQW:         0x0e002 << 15,       // vseq.w
	AXVSEQW:        0x0e802 << 15,       // xvseq.w
	AVSEQV:         0x0e003 << 15,       // vseq.d
	AXVSEQV:        0x0e803 << 15,       // xvseq.d
	AVSLTB:         0x0e00c << 15,       // vslt.b
	AVSLTH:         0x0e00d << 15,       // vslt.h
	AVSLTW:         0x0e00e << 15,       // vslt.w
	AVSLTV:         0x0e00f << 15,       // vslt.d
	AVSLTBU:        0x0e010 << 15,       // vslt.bu
	AVSLTHU:        0x0e011 << 15,       // vslt.hu
	AVSLTWU:        0x0e012 << 15,       // vslt.wu
	AVSLTVU:        0x0e013 << 15,       // vslt.du
	AXVSLTB:        0x0e80c << 15,       // xvslt.b
	AXVSLTH:        0x0e80d << 15,       // xvslt.h
	AXVSLTW:        0x0e80e << 15,       // xvslt.w
	AXVSLTV:        0x0e80f << 15,       // xvslt.d
	AXVSLTBU:       0x0e810 << 15,       // xvslt.bu
	AXVSLTHU:       0x0e811 << 15,       // xvslt.hu
	AXVSLTWU:       0x0e812 << 15,       // xvslt.wu
	AXVSLTVU:       0x0e813 << 15,       // xvslt.du
	AVANDV:         0x0e24c << 15,       // vand.v
	AVORV:          0x0e24d << 15,       // vor.v
	AVXORV:         0x0e24e << 15,       // vxor.v
	AVNORV:         0x0e24f << 15,       // vnor.v
	AVANDNV:        0x0e250 << 15,       // vandn.v
	AVORNV:         0x0e251 << 15,       // vorn.v
	AXVANDV:        0x0ea4c << 15,       // xvand.v
	AXVORV:         0x0ea4d << 15,       // xvor.v
	AXVXORV:        0x0ea4e << 15,       // xvxor.v
	AXVNORV:        0x0ea4f << 15,       // xvnor.v
	AXVANDNV:       0x0ea50 << 15,       // xvandn.v
	AXVORNV:        0x0ea51 << 15,       // xvorn.v
	AVDIVB:         0xe1c0 << 15,        // vdiv.b
	AVDIVH:         0xe1c1 << 15,        // vdiv.h
	AVDIVW:         0xe1c2 << 15,        // vdiv.w
	AVDIVV:         0xe1c3 << 15,        // vdiv.d
	AVMODB:         0xe1c4 << 15,        // vmod.b
	AVMODH:         0xe1c5 << 15,        // vmod.h
	AVMODW:         0xe1c6 << 15,        // vmod.w
	AVMODV:         0xe1c7 << 15,        // vmod.d
	AVDIVBU:        0xe1c8 << 15,        // vdiv.bu
	AVDIVHU:        0xe1c9 << 15,        // vdiv.hu
	AVDIVWU:        0xe1ca << 15,        // vdiv.wu
	AVDIVVU:        0xe1cb << 15,        // vdiv.du
	AVMODBU:        0xe1cc << 15,        // vmod.bu
	AVMODHU:        0xe1cd << 15,        // vmod.hu
	AVMODWU:        0xe1ce << 15,        // vmod.wu
	AVMODVU:        0xe1cf << 15,        // vmod.du
	AXVDIVB:        0xe9c0 << 15,        // xvdiv.b
	AXVDIVH:        0xe9c1 << 15,        // xvdiv.h
	AXVDIVW:        0xe9c2 << 15,        // xvdiv.w
	AXVDIVV:        0xe9c3 << 15,        // xvdiv.d
	AXVMODB:        0xe9c4 << 15,        // xvmod.b
	AXVMODH:        0xe9c5 << 15,        // xvmod.h
	AXVMODW:        0xe9c6 << 15,        // xvmod.w
	AXVMODV:        0xe9c7 << 15,        // xvmod.d
	AXVDIVBU:       0xe9c8 << 15,        // xvdiv.bu
	AXVDIVHU:       0xe9c9 << 15,        // xvdiv.hu
	AXVDIVWU:       0xe9ca << 15,        // xvdiv.wu
	AXVDIVVU:       0xe9cb << 15,        // xvdiv.du
	AXVMODBU:       0xe9cc << 15,        // xvmod.bu
	AXVMODHU:       0xe9cd << 15,        // xvmod.hu
	AXVMODWU:       0xe9ce << 15,        // xvmod.wu
	AXVMODVU:       0xe9cf << 15,        // xvmod.du
	AVMULWEVHB:     0xe120 << 15,        // vmulwev.h.b
	AVMULWEVWH:     0xe121 << 15,        // vmulwev.w.h
	AVMULWEVVW:     0xe122 << 15,        // vmulwev.d.w
	AVMULWEVQV:     0xe123 << 15,        // vmulwev.q.d
	AVMULWODHB:     0xe124 << 15,        // vmulwod.h.b
	AVMULWODWH:     0xe125 << 15,        // vmulwod.w.h
	AVMULWODVW:     0xe126 << 15,        // vmulwod.d.w
	AVMULWODQV:     0xe127 << 15,        // vmulwod.q.d
	AVMULWEVHBU:    0xe130 << 15,        // vmulwev.h.bu
	AVMULWEVWHU:    0xe131 << 15,        // vmulwev.w.hu
	AVMULWEVVWU:    0xe132 << 15,        // vmulwev.d.wu
	AVMULWEVQVU:    0xe133 << 15,        // vmulwev.q.du
	AVMULWODHBU:    0xe134 << 15,        // vmulwod.h.bu
	AVMULWODWHU:    0xe135 << 15,        // vmulwod.w.hu
	AVMULWODVWU:    0xe136 << 15,        // vmulwod.d.wu
	AVMULWODQVU:    0xe137 << 15,        // vmulwod.q.du
	AVMULWEVHBUB:   0xe140 << 15,        // vmulwev.h.bu.b
	AVMULWEVWHUH:   0xe141 << 15,        // vmulwev.w.hu.h
	AVMULWEVVWUW:   0xe142 << 15,        // vmulwev.d.wu.w
	AVMULWEVQVUV:   0xe143 << 15,        // vmulwev.q.du.d
	AVMULWODHBUB:   0xe144 << 15,        // vmulwod.h.bu.b
	AVMULWODWHUH:   0xe145 << 15,        // vmulwod.w.hu.h
	AVMULWODVWUW:   0xe146 << 15,        // vmulwod.d.wu.w
	AVMULWODQVUV:   0xe147 << 15,        // vmulwod.q.du.d
	AXVMULWEVHB:    0xe920 << 15,        // xvmulwev.h.b
	AXVMULWEVWH:    0xe921 << 15,        // xvmulwev.w.h
	AXVMULWEVVW:    0xe922 << 15,        // xvmulwev.d.w
	AXVMULWEVQV:    0xe923 << 15,        // xvmulwev.q.d
	AXVMULWODHB:    0xe924 << 15,        // xvmulwod.h.b
	AXVMULWODWH:    0xe925 << 15,        // xvmulwod.w.h
	AXVMULWODVW:    0xe926 << 15,        // xvmulwod.d.w
	AXVMULWODQV:    0xe927 << 15,        // xvmulwod.q.d
	AXVMULWEVHBU:   0xe930 << 15,        // xvmulwev.h.bu
	AXVMULWEVWHU:   0xe931 << 15,        // xvmulwev.w.hu
	AXVMULWEVVWU:   0xe932 << 15,        // xvmulwev.d.wu
	AXVMULWEVQVU:   0xe933 << 15,        // xvmulwev.q.du
	AXVMULWODHBU:   0xe934 << 15,        // xvmulwod.h.bu
	AXVMULWODWHU:   0xe935 << 15,        // xvmulwod.w.hu
	AXVMULWODVWU:   0xe936 << 15,        // xvmulwod.d.wu
	AXVMULWODQVU:   0xe937 << 15,        // xvmulwod.q.du
	AXVMULWEVHBUB:  0xe940 << 15,        // xvmulwev.h.bu.b
	AXVMULWEVWHUH:  0xe941 << 15,        // xvmulwev.w.hu.h
	AXVMULWEVVWUW:  0xe942 << 15,        // xvmulwev.d.wu.w
	AXVMULWEVQVUV:  0xe943 << 15,        // xvmulwev.q.du.d
	AXVMULWODHBUB:  0xe944 << 15,        // xvmulwod.h.bu.b
	AXVMULWODWHUH:  0xe945 << 15,        // xvmulwod.w.hu.h
	AXVMULWODVWUW:  0xe946 << 15,        // xvmulwod.d.wu.w
	AXVMULWODQVUV:  0xe947 << 15,        // xvmulwod.q.du.d
	AVADDWEVHB:     0x0e03c << 15,       // vaddwev.h.b
	AVADDWEVWH:     0x0e03d << 15,       // vaddwev.w.h
	AVADDWEVVW:     0x0e03e << 15,       // vaddwev.d.w
	AVADDWEVQV:     0x0e03f << 15,       // vaddwev.q.d
	AVSUBWEVHB:     0x0e040 << 15,       // vsubwev.h.b
	AVSUBWEVWH:     0x0e041 << 15,       // vsubwev.w.h
	AVSUBWEVVW:     0x0e042 << 15,       // vsubwev.d.w
	AVSUBWEVQV:     0x0e043 << 15,       // vsubwev.q.d
	AVADDWODHB:     0x0e044 << 15,       // vaddwod.h.b
	AVADDWODWH:     0x0e045 << 15,       // vaddwod.w.h
	AVADDWODVW:     0x0e046 << 15,       // vaddwod.d.w
	AVADDWODQV:     0x0e047 << 15,       // vaddwod.q.d
	AVSUBWODHB:     0x0e048 << 15,       // vsubwod.h.b
	AVSUBWODWH:     0x0e049 << 15,       // vsubwod.w.h
	AVSUBWODVW:     0x0e04a << 15,       // vsubwod.d.w
	AVSUBWODQV:     0x0e04b << 15,       // vsubwod.q.d
	AXVADDWEVHB:    0x0e83c << 15,       // xvaddwev.h.b
	AXVADDWEVWH:    0x0e83d << 15,       // xvaddwev.w.h
	AXVADDWEVVW:    0x0e83e << 15,       // xvaddwev.d.w
	AXVADDWEVQV:    0x0e83f << 15,       // xvaddwev.q.d
	AXVSUBWEVHB:    0x0e840 << 15,       // xvsubwev.h.b
	AXVSUBWEVWH:    0x0e841 << 15,       // xvsubwev.w.h
	AXVSUBWEVVW:    0x0e842 << 15,       // xvsubwev.d.w
	AXVSUBWEVQV:    0x0e843 << 15,       // xvsubwev.q.d
	AXVADDWODHB:    0x0e844 << 15,       // xvaddwod.h.b
	AXVADDWODWH:    0x0e845 << 15,       // xvaddwod.w.h
	AXVADDWODVW:    0x0e846 << 15,       // xvaddwod.d.w
	AXVADDWODQV:    0x0e847 << 15,       // xvaddwod.q.d
	AXVSUBWODHB:    0x0e848 << 15,       // xvsubwod.h.b
	AXVSUBWODWH:    0x0e849 << 15,       // xvsubwod.w.h
	AXVSUBWODVW:    0x0e84a << 15,       // xvsubwod.d.w
	AXVSUBWODQV:    0x0e84b << 15,       // xvsubwod.q.d
	AVADDWEVHBU:    0x0e05c << 15,       // vaddwev.h.bu
	AVADDWEVWHU:    0x0e05d << 15,       // vaddwev.w.hu
	AVADDWEVVWU:    0x0e05e << 15,       // vaddwev.d.wu
	AVADDWEVQVU:    0x0e05f << 15,       // vaddwev.q.du
	AVSUBWEVHBU:    0x0e060 << 15,       // vsubwev.h.bu
	AVSUBWEVWHU:    0x0e061 << 15,       // vsubwev.w.hu
	AVSUBWEVVWU:    0x0e062 << 15,       // vsubwev.d.wu
	AVSUBWEVQVU:    0x0e063 << 15,       // vsubwev.q.du
	AVADDWODHBU:    0x0e064 << 15,       // vaddwod.h.bu
	AVADDWODWHU:    0x0e065 << 15,       // vaddwod.w.hu
	AVADDWODVWU:    0x0e066 << 15,       // vaddwod.d.wu
	AVADDWODQVU:    0x0e067 << 15,       // vaddwod.q.du
	AVSUBWODHBU:    0x0e068 << 15,       // vsubwod.h.bu
	AVSUBWODWHU:    0x0e069 << 15,       // vsubwod.w.hu
	AVSUBWODVWU:    0x0e06a << 15,       // vsubwod.d.wu
	AVSUBWODQVU:    0x0e06b << 15,       // vsubwod.q.du
	AXVADDWEVHBU:   0x0e85c << 15,       // xvaddwev.h.bu
	AXVADDWEVWHU:   0x0e85d << 15,       // xvaddwev.w.hu
	AXVADDWEVVWU:   0x0e85e << 15,       // xvaddwev.d.wu
	AXVADDWEVQVU:   0x0e85f << 15,       // xvaddwev.q.du
	AXVSUBWEVHBU:   0x0e860 << 15,       // xvsubwev.h.bu
	AXVSUBWEVWHU:   0x0e861 << 15,       // xvsubwev.w.hu
	AXVSUBWEVVWU:   0x0e862 << 15,       // xvsubwev.d.wu
	AXVSUBWEVQVU:   0x0e863 << 15,       // xvsubwev.q.du
	AXVADDWODHBU:   0x0e864 << 15,       // xvaddwod.h.bu
	AXVADDWODWHU:   0x0e865 << 15,       // xvaddwod.w.hu
	AXVADDWODVWU:   0x0e866 << 15,       // xvaddwod.d.wu
	AXVADDWODQVU:   0x0e867 << 15,       // xvaddwod.q.du
	AXVSUBWODHBU:   0x0e868 << 15,       // xvsubwod.h.bu
	AXVSUBWODWHU:   0x0e869 << 15,       // xvsubwod.w.hu
	AXVSUBWODVWU:   0x0e86a << 15,       // xvsubwod.d.wu
	AXVSUBWODQVU:   0x0e86b << 15,       // xvsubwod.q.du
	AVMADDB:        0x0e150 << 15,       // vmadd.b
	AVMADDH:        0x0e151 << 15,       // vmadd.h
	AVMADDW:        0x0e152 << 15,       // vmadd.w
	AVMADDV:        0x0e153 << 15,       // vmadd.d
	AVMSUBB:        0x0e154 << 15,       // vmsub.b
	AVMSUBH:        0x0e155 << 15,       // vmsub.h
	AVMSUBW:        0x0e156 << 15,       // vmsub.w
	AVMSUBV:        0x0e157 << 15,       // vmsub.d
	AXVMADDB:       0x0e950 << 15,       // xvmadd.b
	AXVMADDH:       0x0e951 << 15,       // xvmadd.h
	AXVMADDW:       0x0e952 << 15,       // xvmadd.w
	AXVMADDV:       0x0e953 << 15,       // xvmadd.d
	AXVMSUBB:       0x0e954 << 15,       // xvmsub.b
	AXVMSUBH:       0x0e955 << 15,       // xvmsub.h
	AXVMSUBW:       0x0e956 << 15,       // xvmsub.w
	AXVMSUBV:       0x0e957 << 15,       // xvmsub.d
	AVMADDWEVHB:    0x0e158 << 15,       // vmaddwev.h.b
	AVMADDWEVWH:    0x0e159 << 15,       // vmaddwev.w.h
	AVMADDWEVVW:    0x0e15a << 15,       // vmaddwev.d.w
	AVMADDWEVQV:    0x0e15b << 15,       // vmaddwev.q.d
	AVMADDWODHB:    0x0e15c << 15,       // vmaddwod.h.b
	AVMADDWODWH:    0x0e15d << 15,       // vmaddwod.w.h
	AVMADDWODVW:    0x0e15e << 15,       // vmaddwod.d.w
	AVMADDWODQV:    0x0e15f << 15,       // vmaddwod.q.d
	AVMADDWEVHBU:   0x0e168 << 15,       // vmaddwev.h.bu
	AVMADDWEVWHU:   0x0e169 << 15,       // vmaddwev.w.hu
	AVMADDWEVVWU:   0x0e16a << 15,       // vmaddwev.d.wu
	AVMADDWEVQVU:   0x0e16b << 15,       // vmaddwev.q.du
	AVMADDWODHBU:   0x0e16c << 15,       // vmaddwod.h.bu
	AVMADDWODWHU:   0x0e16d << 15,       // vmaddwod.w.hu
	AVMADDWODVWU:   0x0e16e << 15,       // vmaddwod.d.wu
	AVMADDWODQVU:   0x0e16f << 15,       // vmaddwod.q.du
	AVMADDWEVHBUB:  0x0e178 << 15,       // vmaddwev.h.bu.b
	AVMADDWEVWHUH:  0x0e179 << 15,       // vmaddwev.w.hu.h
	AVMADDWEVVWUW:  0x0e17a << 15,       // vmaddwev.d.wu.w
	AVMADDWEVQVUV:  0x0e17b << 15,       // vmaddwev.q.du.d
	AVMADDWODHBUB:  0x0e17c << 15,       // vmaddwod.h.bu.b
	AVMADDWODWHUH:  0x0e17d << 15,       // vmaddwod.w.hu.h
	AVMADDWODVWUW:  0x0e17e << 15,       // vmaddwod.d.wu.w
	AVMADDWODQVUV:  0x0e17f << 15,       // vmaddwod.q.du.d
	AXVMADDWEVHB:   0x0e958 << 15,       // xvmaddwev.h.b
	AXVMADDWEVWH:   0x0e959 << 15,       // xvmaddwev.w.h
	AXVMADDWEVVW:   0x0e95a << 15,       // xvmaddwev.d.w
	AXVMADDWEVQV:   0x0e95b << 15,       // xvmaddwev.q.d
	AXVMADDWODHB:   0x0e95c << 15,       // xvmaddwod.h.b
	AXVMADDWODWH:   0x0e95d << 15,       // xvmaddwod.w.h
	AXVMADDWODVW:   0x0e95e << 15,       // xvmaddwod.d.w
	AXVMADDWODQV:   0x0e95f << 15,       // xvmaddwod.q.d
	AXVMADDWEVHBU:  0x0e968 << 15,       // xvmaddwev.h.bu
	AXVMADDWEVWHU:  0x0e969 << 15,       // xvmaddwev.w.hu
	AXVMADDWEVVWU:  0x0e96a << 15,       // xvmaddwev.d.wu
	AXVMADDWEVQVU:  0x0e96b << 15,       // xvmaddwev.q.du
	AXVMADDWODHBU:  0x0e96c << 15,       // xvmaddwod.h.bu
	AXVMADDWODWHU:  0x0e96d << 15,       // xvmaddwod.w.hu
	AXVMADDWODVWU:  0x0e96e << 15,       // xvmaddwod.d.wu
	AXVMADDWODQVU:  0x0e96f << 15,       // xvmaddwod.q.du
	AXVMADDWEVHBUB: 0x0e978 << 15,       // xvmaddwev.h.bu.b
	AXVMADDWEVWHUH: 0x0e979 << 15,       // xvmaddwev.w.hu.h
	AXVMADDWEVVWUW: 0x0e97a << 15,       // xvmaddwev.d.wu.w
	AXVMADDWEVQVUV: 0x0e97b << 15,       // xvmaddwev.q.du.d
	AXVMADDWODHBUB: 0x0e97c << 15,       // xvmaddwod.h.bu.b
	AXVMADDWODWHUH: 0x0e97d << 15,       // xvmaddwod.w.hu.h
	AXVMADDWODVWUW: 0x0e97e << 15,       // xvmaddwod.d.wu.w
	AXVMADDWODQVUV: 0x0e97f << 15,       // xvmaddwod.q.du.d
	AVSLLB:         0xe1d0 << 15,        // vsll.b
	AVSLLH:         0xe1d1 << 15,        // vsll.h
	AVSLLW:         0xe1d2 << 15,        // vsll.w
	AVSLLV:         0xe1d3 << 15,        // vsll.d
	AVSRLB:         0xe1d4 << 15,        // vsrl.b
	AVSRLH:         0xe1d5 << 15,        // vsrl.h
	AVSRLW:         0xe1d6 << 15,        // vsrl.w
	AVSRLV:         0xe1d7 << 15,        // vsrl.d
	AVSRAB:         0xe1d8 << 15,        // vsra.b
	AVSRAH:         0xe1d9 << 15,        // vsra.h
	AVSRAW:         0xe1da << 15,        // vsra.w
	AVSRAV:         0xe1db << 15,        // vsra.d
	AVROTRB:        0xe1dc << 15,        // vrotr.b
	AVROTRH:        0xe1dd << 15,        // vrotr.h
	AVROTRW:        0xe1de << 15,        // vrotr.w
	AVROTRV:        0xe1df << 15,        // vrotr.d
	AXVSLLB:        0xe9d0 << 15,        // xvsll.b
	AXVSLLH:        0xe9d1 << 15,        // xvsll.h
	AXVSLLW:        0xe9d2 << 15,        // xvsll.w
	AXVSLLV:        0xe9d3 << 15,        // xvsll.d
	AXVSRLB:        0xe9d4 << 15,        // xvsrl.b
	AXVSRLH:        0xe9d5 << 15,        // xvsrl.h
	AXVSRLW:        0xe9d6 << 15,        // xvsrl.w
	AXVSRLV:        0xe9d7 << 15,        // xvsrl.d
	AXVSRAB:        0xe9d8 << 15,        // xvsra.b
	AXVSRAH:        0xe9d9 << 15,        // xvsra.h
	AXVSRAW:        0xe9da << 15,        // xvsra.w
	AXVSRAV:        0xe9db << 15,        // xvsra.d
	AXVROTRB:       0xe9dc << 15,        // xvrotr.b
	AXVROTRH:       0xe9dd << 15,        // xvrotr.h
	AXVROTRW:       0xe9de << 15,        // xvrotr.w
	AXVROTRV:       0xe9df << 15,        // xvrotr.d
	AVADDB:         0xe014 << 15,        // vadd.b
	AVADDH:         0xe015 << 15,        // vadd.h
	AVADDW:         0xe016 << 15,        // vadd.w
	AVADDV:         0xe017 << 15,        // vadd.d
	AVADDQ:         0xe25a << 15,        // vadd.q
	AVSUBB:         0xe018 << 15,        // vsub.b
	AVSUBH:         0xe019 << 15,        // vsub.h
	AVSUBW:         0xe01a << 15,        // vsub.w
	AVSUBV:         0xe01b << 15,        // vsub.d
	AVSUBQ:         0xe25b << 15,        // vsub.q
	AXVADDB:        0xe814 << 15,        // xvadd.b
	AXVADDH:        0xe815 << 15,        // xvadd.h
	AXVADDW:        0xe816 << 15,        // xvadd.w
	AXVADDV:        0xe817 << 15,        // xvadd.d
	AXVADDQ:        0xea5a << 15,        // xvadd.q
	AXVSUBB:        0xe818 << 15,        // xvsub.b
	AXVSUBH:        0xe819 << 15,        // xvsub.h
	AXVSUBW:        0xe81a << 15,        // xvsub.w
	AXVSUBV:        0xe81b << 15,        // xvsub.d
	AXVSUBQ:        0xea5b << 15,        // xvsub.q
	AVSADDB:        0x0e08c << 15,       // vsadd.b
	AVSADDH:        0x0e08d << 15,       // vsadd.h
	AVSADDW:        0x0e08e << 15,       // vsadd.w
	AVSADDV:        0x0e08f << 15,       // vsadd.d
	AVSSUBB:        0x0e090 << 15,       // vssub.b
	AVSSUBH:        0x0e091 << 15,       // vssub.w
	AVSSUBW:        0x0e092 << 15,       // vssub.h
	AVSSUBV:        0x0e093 << 15,       // vssub.d
	AVSADDBU:       0x0e094 << 15,       // vsadd.bu
	AVSADDHU:       0x0e095 << 15,       // vsadd.hu
	AVSADDWU:       0x0e096 << 15,       // vsadd.wu
	AVSADDVU:       0x0e097 << 15,       // vsadd.du
	AVSSUBBU:       0x0e098 << 15,       // vssub.bu
	AVSSUBHU:       0x0e099 << 15,       // vssub.wu
	AVSSUBWU:       0x0e09a << 15,       // vssub.hu
	AVSSUBVU:       0x0e09b << 15,       // vssub.du
	AXVSADDB:       0x0e88c << 15,       // vxsadd.b
	AXVSADDH:       0x0e88d << 15,       // vxsadd.h
	AXVSADDW:       0x0e88e << 15,       // vxsadd.w
	AXVSADDV:       0x0e88f << 15,       // vxsadd.d
	AXVSSUBB:       0x0e890 << 15,       // xvssub.b
	AXVSSUBH:       0x0e891 << 15,       // xvssub.h
	AXVSSUBW:       0x0e892 << 15,       // xvssub.w
	AXVSSUBV:       0x0e893 << 15,       // xvssub.d
	AXVSADDBU:      0x0e894 << 15,       // vxsadd.bu
	AXVSADDHU:      0x0e895 << 15,       // vxsadd.hu
	AXVSADDWU:      0x0e896 << 15,       // vxsadd.wu
	AXVSADDVU:      0x0e897 << 15,       // vxsadd.du
	AXVSSUBBU:      0x0e898 << 15,       // xvssub.bu
	AXVSSUBHU:      0x0e899 << 15,       // xvssub.hu
	AXVSSUBWU:      0x0e89a << 15,       // xvssub.wu
	AXVSSUBVU:      0x0e89b << 15,       // xvssub.du
	AVILVLB:        0xe234 << 15,        // vilvl.b
	AVILVLH:        0xe235 << 15,        // vilvl.h
	AVILVLW:        0xe236 << 15,        // vilvl.w
	AVILVLV:        0xe237 << 15,        // vilvl.d
	AVILVHB:        0xe238 << 15,        // vilvh.b
	AVILVHH:        0xe239 << 15,        // vilvh.h
	AVILVHW:        0xe23a << 15,        // vilvh.w
	AVILVHV:        0xe23b << 15,        // vilvh.d
	AXVILVLB:       0xea34 << 15,        // xvilvl.b
	AXVILVLH:       0xea35 << 15,        // xvilvl.h
	AXVILVLW:       0xea36 << 15,        // xvilvl.w
	AXVILVLV:       0xea37 << 15,        // xvilvl.d
	AXVILVHB:       0xea38 << 15,        // xvilvh.b
	AXVILVHH:       0xea39 << 15,        // xvilvh.h
	AXVILVHW:       0xea3a << 15,        // xvilvh.w
	AXVILVHV:       0xea3b << 15,        // xvilvh.d
	AVMULB:         0xe108 << 15,        // vmul.b
	AVMULH:         0xe109 << 15,        // vmul.h
	AVMULW:         0xe10a << 15,        // vmul.w
	AVMULV:         0xe10b << 15,        // vmul.d
	AVMUHB:         0xe10c << 15,        // vmuh.b
	AVMUHH:         0xe10d << 15,        // vmuh.h
	AVMUHW:         0xe10e << 15,        // vmuh.w
	AVMUHV:         0xe10f << 15,        // vmuh.d
	AVMUHBU:        0xe110 << 15,        // vmuh.bu
	AVMUHHU:        0xe111 << 15,        // vmuh.hu
	AVMUHWU:        0xe112 << 15,        // vmuh.wu
	AVMUHVU:        0xe113 << 15,        // vmuh.du
	AXVMULB:        0xe908 << 15,        // xvmul.b
	AXVMULH:        0xe909 << 15,        // xvmul.h
	AXVMULW:        0xe90a << 15,        // xvmul.w
	AXVMULV:        0xe90b << 15,        // xvmul.d
	AXVMUHB:        0xe90c << 15,        // xvmuh.b
	AXVMUHH:        0xe90d << 15,        // xvmuh.h
	AXVMUHW:        0xe90e << 15,        // xvmuh.w
	AXVMUHV:        0xe90f << 15,        // xvmuh.d
	AXVMUHBU:       0xe910 << 15,        // xvmuh.bu
	AXVMUHHU:       0xe911 << 15,        // xvmuh.hu
	AXVMUHWU:       0xe912 << 15,        // xvmuh.wu
	AXVMUHVU:       0xe913 << 15,        // xvmuh.du
	AVADDF:         0xe261 << 15,        // vfadd.s
	AVADDD:         0xe262 << 15,        // vfadd.d
	AVSUBF:         0xe265 << 15,        // vfsub.s
	AVSUBD:         0xe266 << 15,        // vfsub.d
	AVMULF:         0xe271 << 15,        // vfmul.s
	AVMULD:         0xe272 << 15,        // vfmul.d
	AVDIVF:         0xe275 << 15,        // vfdiv.s
	AVDIVD:         0xe276 << 15,        // vfdiv.d
	AXVADDF:        0xea61 << 15,        // xvfadd.s
	AXVADDD:        0xea62 << 15,        // xvfadd.d
	AXVSUBF:        0xea65 << 15,        // xvfsub.s
	AXVSUBD:        0xea66 << 15,        // xvfsub.d
	AXVMULF:        0xea71 << 15,        // xvfmul.s
	AXVMULD:        0xea72 << 15,        // xvfmul.d
	AXVDIVF:        0xea75 << 15,        // xvfdiv.s
	AXVDIVD:        0xea76 << 15,        // xvfdiv.d
	AVBITCLRB:      0xe218 << 15,        // vbitclr.b
	AVBITCLRH:      0xe219 << 15,        // vbitclr.h
	AVBITCLRW:      0xe21a << 15,        // vbitclr.w
	AVBITCLRV:      0xe21b << 15,        // vbitclr.d
	AVBITSETB:      0xe21c << 15,        // vbitset.b
	AVBITSETH:      0xe21d << 15,        // vbitset.h
	AVBITSETW:      0xe21e << 15,        // vbitset.w
	AVBITSETV:      0xe21f << 15,        // vbitset.d
	AVBITREVB:      0xe220 << 15,        // vbitrev.b
	AVBITREVH:      0xe221 << 15,        // vbitrev.h
	AVBITREVW:      0xe222 << 15,        // vbitrev.w
	AVBITREVV:      0xe223 << 15,        // vbitrev.d
	AXVBITCLRB:     0xea18 << 15,        // xvbitclr.b
	AXVBITCLRH:     0xea19 << 15,        // xvbitclr.h
	AXVBITCLRW:     0xea1a << 15,        // xvbitclr.w
	AXVBITCLRV:     0xea1b << 15,        // xvbitclr.d
	AXVBITSETB:     0xea1c << 15,        // xvbitset.b
	AXVBITSETH:     0xea1d << 15,        // xvbitset.h
	AXVBITSETW:     0xea1e << 15,        // xvbitset.w
	AXVBITSETV:     0xea1f << 15,        // xvbitset.d
	AXVBITREVB:     0xea20 << 15,        // xvbitrev.b
	AXVBITREVH:     0xea21 << 15,        // xvbitrev.h
	AXVBITREVW:     0xea22 << 15,        // xvbitrev.w
	AXVBITREVV:     0xea23 << 15,        // xvbitrev.d
	AVSHUFH:        0x0e2f5 << 15,       // vshuf.h
	AVSHUFW:        0x0e2f6 << 15,       // vshuf.w
	AVSHUFV:        0x0e2f7 << 15,       // vshuf.d
	AXVSHUFH:       0x0eaf5 << 15,       // xvshuf.h
	AXVSHUFW:       0x0eaf6 << 15,       // xvshuf.w
	AXVSHUFV:       0x0eaf7 << 15,       // xvshuf.d
}

var oprr = map[obj.As]uint32{
	ACLOW:        0x4 << 10,             // clo.w
	ACLZW:        0x5 << 10,             // clz.w
	ACTOW:        0x6 << 10,             // cto.w
	ACTZW:        0x7 << 10,             // ctz.w
	ACLOV:        0x8 << 10,             // clo.d
	ACLZV:        0x9 << 10,             // clz.d
	ACTOV:        0xa << 10,             // cto.d
	ACTZV:        0xb << 10,             // ctz.d
	AREVB2H:      0xc << 10,             // revb.2h
	AREVB4H:      0xd << 10,             // revb.4h
	AREVB2W:      0xe << 10,             // revb.2w
	AREVBV:       0xf << 10,             // revb.d
	AREVH2W:      0x10 << 10,            // revh.2w
	AREVHV:       0x11 << 10,            // revh.d
	ABITREV4B:    0x12 << 10,            // bitrev.4b
	ABITREV8B:    0x13 << 10,            // bitrev.8b
	ABITREVW:     0x14 << 10,            // bitrev.w
	ABITREVV:     0x15 << 10,            // bitrev.d
	AEXTWH:       0x16 << 10,            // ext.w.h
	AEXTWB:       0x17 << 10,            // ext.w.h
	ACPUCFG:      0x1b << 10,            // cpucfg
	ARDTIMELW:    0x18 << 10,            // rdtimel.w
	ARDTIMEHW:    0x19 << 10,            // rdtimeh.w
	ARDTIMED:     0x1a << 10,            // rdtime.d
	ALLACQW:      0x0E15E0 << 10,        // ll.acq.w
	ASCRELW:      0x0E15E1 << 10,        // sc.rel.w
	ALLACQV:      0x0E15E2 << 10,        // ll.acq.d
	ASCRELV:      0x0E15E3 << 10,        // sc.rel.d
	ATRUNCFV:     0x46a9 << 10,          // ftintrz.l.s
	ATRUNCDV:     0x46aa << 10,          // ftintrz.l.d
	ATRUNCFW:     0x46a1 << 10,          // ftintrz.w.s
	ATRUNCDW:     0x46a2 << 10,          // ftintrz.w.d
	AMOVWF:       0x4744 << 10,          // ffint.s.w
	AFFINTFW:     0x4744 << 10,          // ffint.s.w
	AMOVVF:       0x4746 << 10,          // ffint.s.l
	AFFINTFV:     0x4746 << 10,          // ffint.s.l
	AMOVWD:       0x4748 << 10,          // ffint.d.w
	AFFINTDW:     0x4748 << 10,          // ffint.d.w
	AMOVVD:       0x474a << 10,          // ffint.d.l
	AFFINTDV:     0x474a << 10,          // ffint.d.l
	AMOVFW:       0x46c1 << 10,          // ftint.w.s
	AFTINTWF:     0x46c1 << 10,          // ftint.w.s
	AMOVDW:       0x46c2 << 10,          // ftint.w.d
	AFTINTWD:     0x46c2 << 10,          // ftint.w.d
	AMOVFV:       0x46c9 << 10,          // ftint.l.s
	AFTINTVF:     0x46c9 << 10,          // ftint.l.s
	AMOVDV:       0x46ca << 10,          // ftint.l.d
	AFTINTVD:     0x46ca << 10,          // ftint.l.d
	AFRINTF:      0x4791 << 10,          // frint.s
	AFRINTD:      0x4792 << 10,          // frint.d
	AMOVDF:       0x4646 << 10,          // fcvt.s.d
	AMOVFD:       0x4649 << 10,          // fcvt.d.s
	AABSF:        0x4501 << 10,          // fabs.s
	AABSD:        0x4502 << 10,          // fabs.d
	AMOVF:        0x4525 << 10,          // fmov.s
	AMOVD:        0x4526 << 10,          // fmov.d
	ANEGF:        0x4505 << 10,          // fneg.s
	ANEGD:        0x4506 << 10,          // fneg.d
	ASQRTF:       0x4511 << 10,          // fsqrt.s
	ASQRTD:       0x4512 << 10,          // fsqrt.d
	AFLOGBF:      0x4509 << 10,          // flogb.s
	AFLOGBD:      0x450a << 10,          // flogb.d
	AFCLASSF:     0x450d << 10,          // fclass.s
	AFCLASSD:     0x450e << 10,          // fclass.d
	AFTINTRMWF:   0x4681 << 10,          // ftintrm.w.s
	AFTINTRMWD:   0x4682 << 10,          // ftintrm.w.d
	AFTINTRMVF:   0x4689 << 10,          // ftintrm.l.s
	AFTINTRMVD:   0x468a << 10,          // ftintrm.l.d
	AFTINTRPWF:   0x4691 << 10,          // ftintrp.w.s
	AFTINTRPWD:   0x4692 << 10,          // ftintrp.w.d
	AFTINTRPVF:   0x4699 << 10,          // ftintrp.l.s
	AFTINTRPVD:   0x469a << 10,          // ftintrp.l.d
	AFTINTRZWF:   0x46a1 << 10,          // ftintrz.w.s
	AFTINTRZWD:   0x46a2 << 10,          // ftintrz.w.d
	AFTINTRZVF:   0x46a9 << 10,          // ftintrz.l.s
	AFTINTRZVD:   0x46aa << 10,          // ftintrz.l.d
	AFTINTRNEWF:  0x46b1 << 10,          // ftintrne.w.s
	AFTINTRNEWD:  0x46b2 << 10,          // ftintrne.w.d
	AFTINTRNEVF:  0x46b9 << 10,          // ftintrne.l.s
	AFTINTRNEVD:  0x46ba << 10,          // ftintrne.l.d
	AVPCNTB:      0x1ca708 << 10,        // vpcnt.b
	AVPCNTH:      0x1ca709 << 10,        // vpcnt.h
	AVPCNTW:      0x1ca70a << 10,        // vpcnt.w
	AVPCNTV:      0x1ca70b << 10,        // vpcnt.v
	AXVPCNTB:     0x1da708 << 10,        // xvpcnt.b
	AXVPCNTH:     0x1da709 << 10,        // xvpcnt.h
	AXVPCNTW:     0x1da70a << 10,        // xvpcnt.w
	AXVPCNTV:     0x1da70b << 10,        // xvpcnt.v
	AVFSQRTF:     0x1ca739 << 10,        // vfsqrt.s
	AVFSQRTD:     0x1ca73a << 10,        // vfsqrt.d
	AVFRECIPF:    0x1ca73d << 10,        // vfrecip.s
	AVFRECIPD:    0x1ca73e << 10,        // vfrecip.d
	AVFRSQRTF:    0x1ca741 << 10,        // vfrsqrt.s
	AVFRSQRTD:    0x1ca742 << 10,        // vfrsqrt.d
	AXVFSQRTF:    0x1da739 << 10,        // xvfsqrt.s
	AXVFSQRTD:    0x1da73a << 10,        // xvfsqrt.d
	AXVFRECIPF:   0x1da73d << 10,        // xvfrecip.s
	AXVFRECIPD:   0x1da73e << 10,        // xvfrecip.d
	AXVFRSQRTF:   0x1da741 << 10,        // xvfrsqrt.s
	AXVFRSQRTD:   0x1da742 << 10,        // xvfrsqrt.d
	AVNEGB:       0x1ca70c << 10,        // vneg.b
	AVNEGH:       0x1ca70d << 10,        // vneg.h
	AVNEGW:       0x1ca70e << 10,        // vneg.w
	AVNEGV:       0x1ca70f << 10,        // vneg.d
	AXVNEGB:      0x1da70c << 10,        // xvneg.b
	AXVNEGH:      0x1da70d << 10,        // xvneg.h
	AXVNEGW:      0x1da70e << 10,        // xvneg.w
	AXVNEGV:      0x1da70f << 10,        // xvneg.d
	AVFRINTRNEF:  0x1ca75d << 10,        // vfrintrne.s
	AVFRINTRNED:  0x1ca75e << 10,        // vfrintrne.d
	AVFRINTRZF:   0x1ca759 << 10,        // vfrintrz.s
	AVFRINTRZD:   0x1ca75a << 10,        // vfrintrz.d
	AVFRINTRPF:   0x1ca755 << 10,        // vfrintrp.s
	AVFRINTRPD:   0x1ca756 << 10,        // vfrintrp.d
	AVFRINTRMF:   0x1ca751 << 10,        // vfrintrm.s
	AVFRINTRMD:   0x1ca752 << 10,        // vfrintrm.d
	AVFRINTF:     0x1ca74d << 10,        // vfrint.s
	AVFRINTD:     0x1ca74e << 10,        // vfrint.d
	AXVFRINTRNEF: 0x1da75d << 10,        // xvfrintrne.s
	AXVFRINTRNED: 0x1da75e << 10,        // xvfrintrne.d
	AXVFRINTRZF:  0x1da759 << 10,        // xvfrintrz.s
	AXVFRINTRZD:  0x1da75a << 10,        // xvfrintrz.d
	AXVFRINTRPF:  0x1da755 << 10,        // xvfrintrp.s
	AXVFRINTRPD:  0x1da756 << 10,        // xvfrintrp.d
	AXVFRINTRMF:  0x1da751 << 10,        // xvfrintrm.s
	AXVFRINTRMD:  0x1da752 << 10,        // xvfrintrm.d
	AXVFRINTF:    0x1da74d << 10,        // xvfrint.s
	AXVFRINTD:    0x1da74e << 10,        // xvfrint.d
	AVFCLASSF:    0x1ca735 << 10,        // vfclass.s
	AVFCLASSD:    0x1ca736 << 10,        // vfclass.d
	AXVFCLASSF:   0x1da735 << 10,        // xvfclass.s
	AXVFCLASSD:   0x1da736 << 10,        // xvfclass.d
	AVSETEQV:     0x1ca726<<10 | 0x0<<3, // vseteqz.v
	AVSETNEV:     0x1ca727<<10 | 0x0<<3, // vsetnez.v
	AVSETANYEQB:  0x1ca728<<10 | 0x0<<3, // vsetanyeqz.b
	AVSETANYEQH:  0x1ca729<<10 | 0x0<<3, // vsetanyeqz.h
	AVSETANYEQW:  0x1ca72a<<10 | 0x0<<3, // vsetanyeqz.w
	AVSETANYEQV:  0x1ca72b<<10 | 0x0<<3, // vsetanyeqz.d
	AVSETALLNEB:  0x1ca72c<<10 | 0x0<<3, // vsetallnez.b
	AVSETALLNEH:  0x1ca72d<<10 | 0x0<<3, // vsetallnez.h
	AVSETALLNEW:  0x1ca72e<<10 | 0x0<<3, // vsetallnez.w
	AVSETALLNEV:  0x1ca72f<<10 | 0x0<<3, // vsetallnez.d
	AXVSETEQV:    0x1da726<<10 | 0x0<<3, // xvseteqz.v
	AXVSETNEV:    0x1da727<<10 | 0x0<<3, // xvsetnez.v
	AXVSETANYEQB: 0x1da728<<10 | 0x0<<3, // xvsetanyeqz.b
	AXVSETANYEQH: 0x1da729<<10 | 0x0<<3, // xvsetanyeqz.h
	AXVSETANYEQW: 0x1da72a<<10 | 0x0<<3, // xvsetanyeqz.w
	AXVSETANYEQV: 0x1da72b<<10 | 0x0<<3, // xvsetanyeqz.d
	AXVSETALLNEB: 0x1da72c<<10 | 0x0<<3, // xvsetallnez.b
	AXVSETALLNEH: 0x1da72d<<10 | 0x0<<3, // xvsetallnez.h
	AXVSETALLNEW: 0x1da72e<<10 | 0x0<<3, // xvsetallnez.w
	AXVSETALLNEV: 0x1da72f<<10 | 0x0<<3, // xvsetallnez.d
}

var opi = map[obj.As]uint32{
	ASYSCALL: 0x56 << 15,   // syscall
	ABREAK:   0x54 << 15,   // break
	ADBAR:    0x70e4 << 15, // dbar
}

var opir = map[obj.As]uint32{
	ALU12IW:    0x0a << 25, // lu12i.w
	ALU32ID:    0x0b << 25, // lu32i.d
	APCALAU12I: 0x0d << 25, // pcalau12i
	APCADDU12I: 0x0e << 25, // pcaddu12i
}

var opirr = map[obj.As]uint32{
	ASGT:        0x008 << 22,          // slti
	ASGTU:       0x009 << 22,          // sltui
	AADD:        0x00a << 22,          // addi.w
	AADDW:       0x00a << 22,          // addi.w
	AADDV:       0x00b << 22,          // addi.d
	AADDVU:      0x00b << 22,          // addi.d
	ALU52ID:     0x00c << 22,          // lu52i.d
	AAND:        0x00d << 22,          // andi
	AOR:         0x00e << 22,          // ori
	AXOR:        0x00f << 22,          // xori
	ASLL:        0x00081 << 15,        // slli.w
	ASRL:        0x00089 << 15,        // srli.w
	ASRA:        0x00091 << 15,        // srai.w
	AROTR:       0x00099 << 15,        // rotri.w
	AADDV16:     0x4 << 26,            // addu16i.d
	-ABEQ:       0x10 << 26,           // beqz
	-ABNE:       0x11 << 26,           // bnez
	AJIRL:       0x13 << 26,           // jirl
	AJMP:        0x14 << 26,           // b
	AJAL:        0x15 << 26,           // bl
	ABEQ:        0x16 << 26,           // beq
	ABNE:        0x17 << 26,           // bne
	ABLT:        0x18 << 26,           // blt
	ABLTZ:       0x18 << 26,           // blt
	ABGTZ:       0x18 << 26,           // blt
	ABGE:        0x19 << 26,           // bge
	ABGEZ:       0x19 << 26,           // bge
	ABLEZ:       0x19 << 26,           // bge
	ABLTU:       0x1a << 26,           // bltu
	ABGEU:       0x1b << 26,           // bgeu
	ABFPT:       0x12<<26 | 0x1<<8,    // bcnez
	ABFPF:       0x12<<26 | 0x0<<8,    // bceqz
	APRELDX:     0x07058 << 15,        // preldx
	-AMOVB:      0x0a0 << 22,          // ld.b
	-AMOVH:      0x0a1 << 22,          // ld.h
	-AMOVW:      0x0a2 << 22,          // ld.w
	-AMOVV:      0x0a3 << 22,          // ld.d
	AMOVB:       0x0a4 << 22,          // st.b
	AMOVBU:      0x0a4 << 22,          // st.b
	AMOVH:       0x0a5 << 22,          // st.h
	AMOVHU:      0x0a5 << 22,          // st.h
	AMOVW:       0x0a6 << 22,          // st.w
	AMOVWU:      0x0a6 << 22,          // st.w
	AMOVV:       0x0a7 << 22,          // st.d
	-AMOVBU:     0x0a8 << 22,          // ld.bu
	-AMOVHU:     0x0a9 << 22,          // ld.hu
	-AMOVWU:     0x0aa << 22,          // ld.wu
	-AMOVF:      0x0ac << 22,          // fld.s
	AMOVF:       0x0ad << 22,          // fst.s
	-AMOVD:      0x0ae << 22,          // fld.d
	AMOVD:       0x0af << 22,          // fst.d
	-ALL:        0x020 << 24,          // ll.w
	-ALLW:       0x020 << 24,          // ll.w
	ASC:         0x021 << 24,          // sc.w
	ASCW:        0x021 << 24,          // sc.w
	-ALLV:       0x022 << 24,          // ll.d
	ASCV:        0x023 << 24,          // sc.d
	-AMOVWP:     0x24 << 24,           // ldptr.w
	AMOVWP:      0x25 << 24,           // stptr.w
	-AMOVVP:     0x26 << 24,           // ldptr.d
	AMOVVP:      0x27 << 24,           // stptr.d
	-AVMOVQ:     0x0b0 << 22,          // vld
	AVMOVQ:      0x0b1 << 22,          // vst
	-AXVMOVQ:    0x0b2 << 22,          // xvld
	AXVMOVQ:     0x0b3 << 22,          // xvst
	ASLLV:       0x0041 << 16,         // slli.d
	ASRLV:       0x0045 << 16,         // srli.d
	ASRAV:       0x0049 << 16,         // srai.d
	AROTRV:      0x004d << 16,         // rotri.d
	AVANDB:      0x1cf4 << 18,         // vandi.b
	AVORB:       0x1cf5 << 18,         // vori.b
	AVXORB:      0x1cf6 << 18,         // xori.b
	AVNORB:      0x1cf7 << 18,         // xnori.b
	AXVANDB:     0x1df4 << 18,         // xvandi.b
	AXVORB:      0x1df5 << 18,         // xvori.b
	AXVXORB:     0x1df6 << 18,         // xvxori.b
	AXVNORB:     0x1df7 << 18,         // xvnor.b
	AVSEQB:      0x0e500 << 15,        // vseqi.b
	AVSEQH:      0x0e501 << 15,        // vseqi.h
	AVSEQW:      0x0e502 << 15,        // vseqi.w
	AVSEQV:      0x0e503 << 15,        // vseqi.d
	AXVSEQB:     0x0ed00 << 15,        // xvseqi.b
	AXVSEQH:     0x0ed01 << 15,        // xvseqi.h
	AXVSEQW:     0x0ed02 << 15,        // xvseqi.w
	AXVSEQV:     0x0ed03 << 15,        // xvseqi.d
	AVSLTB:      0x0e50c << 15,        // vslti.b
	AVSLTH:      0x0e50d << 15,        // vslti.h
	AVSLTW:      0x0e50e << 15,        // vslti.w
	AVSLTV:      0x0e50f << 15,        // vslti.d
	AVSLTBU:     0x0e510 << 15,        // vslti.bu
	AVSLTHU:     0x0e511 << 15,        // vslti.hu
	AVSLTWU:     0x0e512 << 15,        // vslti.wu
	AVSLTVU:     0x0e513 << 15,        // vslti.du
	AXVSLTB:     0x0ed0c << 15,        // xvslti.b
	AXVSLTH:     0x0ed0d << 15,        // xvslti.h
	AXVSLTW:     0x0ed0e << 15,        // xvslti.w
	AXVSLTV:     0x0ed0f << 15,        // xvslti.d
	AXVSLTBU:    0x0ed10 << 15,        // xvslti.bu
	AXVSLTHU:    0x0ed11 << 15,        // xvslti.hu
	AXVSLTWU:    0x0ed12 << 15,        // xvslti.wu
	AXVSLTVU:    0x0ed13 << 15,        // xvslti.du
	AVROTRB:     0x1ca8<<18 | 0x1<<13, // vrotri.b
	AVROTRH:     0x1ca8<<18 | 0x1<<14, // vrotri.h
	AVROTRW:     0x1ca8<<18 | 0x1<<15, // vrotri.w
	AVROTRV:     0x1ca8<<18 | 0x1<<16, // vrotri.d
	AXVROTRB:    0x1da8<<18 | 0x1<<13, // xvrotri.b
	AXVROTRH:    0x1da8<<18 | 0x1<<14, // xvrotri.h
	AXVROTRW:    0x1da8<<18 | 0x1<<15, // xvrotri.w
	AXVROTRV:    0x1da8<<18 | 0x1<<16, // xvrotri.d
	AVSLLB:      0x1ccb<<18 | 0x1<<13, // vslli.b
	AVSLLH:      0x1ccb<<18 | 0x1<<14, // vslli.h
	AVSLLW:      0x1ccb<<18 | 0x1<<15, // vslli.w
	AVSLLV:      0x1ccb<<18 | 0x1<<16, // vslli.d
	AVSRLB:      0x1ccc<<18 | 0x1<<13, // vsrli.b
	AVSRLH:      0x1ccc<<18 | 0x1<<14, // vsrli.h
	AVSRLW:      0x1ccc<<18 | 0x1<<15, // vsrli.w
	AVSRLV:      0x1ccc<<18 | 0x1<<16, // vsrli.d
	AVSRAB:      0x1ccd<<18 | 0x1<<13, // vsrai.b
	AVSRAH:      0x1ccd<<18 | 0x1<<14, // vsrai.h
	AVSRAW:      0x1ccd<<18 | 0x1<<15, // vsrai.w
	AVSRAV:      0x1ccd<<18 | 0x1<<16, // vsrai.d
	AXVSLLB:     0x1dcb<<18 | 0x1<<13, // xvslli.b
	AXVSLLH:     0x1dcb<<18 | 0x1<<14, // xvslli.h
	AXVSLLW:     0x1dcb<<18 | 0x1<<15, // xvslli.w
	AXVSLLV:     0x1dcb<<18 | 0x1<<16, // xvslli.d
	AXVSRLB:     0x1dcc<<18 | 0x1<<13, // xvsrli.b
	AXVSRLH:     0x1dcc<<18 | 0x1<<14, // xvsrli.h
	AXVSRLW:     0x1dcc<<18 | 0x1<<15, // xvsrli.w
	AXVSRLV:     0x1dcc<<18 | 0x1<<16, // xvsrli.d
	AXVSRAB:     0x1dcd<<18 | 0x1<<13, // xvsrai.b
	AXVSRAH:     0x1dcd<<18 | 0x1<<14, // xvsrai.h
	AXVSRAW:     0x1dcd<<18 | 0x1<<15, // xvsrai.w
	AXVSRAV:     0x1dcd<<18 | 0x1<<16, // xvsrai.d
	AVADDBU:     0xe514 << 15,         // vaddi.bu
	AVADDHU:     0xe515 << 15,         // vaddi.hu
	AVADDWU:     0xe516 << 15,         // vaddi.wu
	AVADDVU:     0xe517 << 15,         // vaddi.du
	AVSUBBU:     0xe518 << 15,         // vsubi.bu
	AVSUBHU:     0xe519 << 15,         // vsubi.hu
	AVSUBWU:     0xe51a << 15,         // vsubi.wu
	AVSUBVU:     0xe51b << 15,         // vsubi.du
	AXVADDBU:    0xed14 << 15,         // xvaddi.bu
	AXVADDHU:    0xed15 << 15,         // xvaddi.hu
	AXVADDWU:    0xed16 << 15,         // xvaddi.wu
	AXVADDVU:    0xed17 << 15,         // xvaddi.du
	AXVSUBBU:    0xed18 << 15,         // xvsubi.bu
	AXVSUBHU:    0xed19 << 15,         // xvsubi.hu
	AXVSUBWU:    0xed1a << 15,         // xvsubi.wu
	AXVSUBVU:    0xed1b << 15,         // xvsubi.du
	AVSHUF4IB:   0x1ce4 << 18,         // vshuf4i.b
	AVSHUF4IH:   0x1ce5 << 18,         // vshuf4i.h
	AVSHUF4IW:   0x1ce6 << 18,         // vshuf4i.w
	AVSHUF4IV:   0x1ce7 << 18,         // vshuf4i.d
	AXVSHUF4IB:  0x1de4 << 18,         // xvshuf4i.b
	AXVSHUF4IH:  0x1de5 << 18,         // xvshuf4i.h
	AXVSHUF4IW:  0x1de6 << 18,         // xvshuf4i.w
	AXVSHUF4IV:  0x1de7 << 18,         // xvshuf4i.d
	AVPERMIW:    0x1cf9 << 18,         // vpermi.w
	AXVPERMIW:   0x1df9 << 18,         // xvpermi.w
	AXVPERMIV:   0x1dfa << 18,         // xvpermi.d
	AXVPERMIQ:   0x1dfb << 18,         // xvpermi.q
	AVEXTRINSB:  0x1ce3 << 18,         // vextrins.b
	AVEXTRINSH:  0x1ce2 << 18,         // vextrins.h
	AVEXTRINSW:  0x1ce1 << 18,         // vextrins.w
	AVEXTRINSV:  0x1ce0 << 18,         // vextrins.d
	AXVEXTRINSB: 0x1de3 << 18,         // xvextrins.b
	AXVEXTRINSH: 0x1de2 << 18,         // xvextrins.h
	AXVEXTRINSW: 0x1de1 << 18,         // xvextrins.w
	AXVEXTRINSV: 0x1de0 << 18,         // xvextrins.d
	AVBITCLRB:   0x1cc4<<18 | 0x1<<13, // vbitclri.b
	AVBITCLRH:   0x1cc4<<18 | 0x1<<14, // vbitclri.h
	AVBITCLRW:   0x1cc4<<18 | 0x1<<15, // vbitclri.w
	AVBITCLRV:   0x1cc4<<18 | 0x1<<16, // vbitclri.d
	AVBITSETB:   0x1cc5<<18 | 0x1<<13, // vbitseti.b
	AVBITSETH:   0x1cc5<<18 | 0x1<<14, // vbitseti.h
	AVBITSETW:   0x1cc5<<18 | 0x1<<15, // vbitseti.w
	AVBITSETV:   0x1cc5<<18 | 0x1<<16, // vbitseti.d
	AVBITREVB:   0x1cc6<<18 | 0x1<<13, // vbitrevi.b
	AVBITREVH:   0x1cc6<<18 | 0x1<<14, // vbitrevi.h
	AVBITREVW:   0x1cc6<<18 | 0x1<<15, // vbitrevi.w
	AVBITREVV:   0x1cc6<<18 | 0x1<<16, // vbitrevi.d
	AXVBITCLRB:  0x1dc4<<18 | 0x1<<13, // xvbitclri.b
	AXVBITCLRH:  0x1dc4<<18 | 0x1<<14, // xvbitclri.h
	AXVBITCLRW:  0x1dc4<<18 | 0x1<<15, // xvbitclri.w
	AXVBITCLRV:  0x1dc4<<18 | 0x1<<16, // xvbitclri.d
	AXVBITSETB:  0x1dc5<<18 | 0x1<<13, // xvbitseti.b
	AXVBITSETH:  0x1dc5<<18 | 0x1<<14, // xvbitseti.h
	AXVBITSETW:  0x1dc5<<18 | 0x1<<15, // xvbitseti.w
	AXVBITSETV:  0x1dc5<<18 | 0x1<<16, // xvbitseti.d
	AXVBITREVB:  0x1dc6<<18 | 0x1<<13, // xvbitrevi.b
	AXVBITREVH:  0x1dc6<<18 | 0x1<<14, // xvbitrevi.h
	AXVBITREVW:  0x1dc6<<18 | 0x1<<15, // xvbitrevi.w
	AXVBITREVV:  0x1dc6<<18 | 0x1<<16, // xvbitrevi.d
}

var opirrr = map[obj.As]uint32{
	AALSLW:  0x2 << 17,  // alsl.w
	AALSLWU: 0x3 << 17,  // alsl.wu
	AALSLV:  0x16 << 17, // alsl.d
}

var opirir = map[obj.As]uint32{
	ABSTRINSW:  0x3<<21 | 0x0<<15, // bstrins.w
	ABSTRINSV:  0x2 << 22,         // bstrins.d
	ABSTRPICKW: 0x3<<21 | 0x1<<15, // bstrpick.w
	ABSTRPICKV: 0x3 << 22,         // bstrpick.d
}

var opiir = map[obj.As]uint32{
	APRELD: 0x0ab << 22, // preld
}

var atomicInst = map[obj.As]uint32{
	AAMSWAPB:   0x070B8 << 15, // amswap.b
	AAMSWAPH:   0x070B9 << 15, // amswap.h
	AAMSWAPW:   0x070C0 << 15, // amswap.w
	AAMSWAPV:   0x070C1 << 15, // amswap.d
	AAMCASB:    0x070B0 << 15, // amcas.b
	AAMCASH:    0x070B1 << 15, // amcas.h
	AAMCASW:    0x070B2 << 15, // amcas.w
	AAMCASV:    0x070B3 << 15, // amcas.d
	AAMADDW:    0x070C2 << 15, // amadd.w
	AAMADDV:    0x070C3 << 15, // amadd.d
	AAMANDW:    0x070C4 << 15, // amand.w
	AAMANDV:    0x070C5 << 15, // amand.d
	AAMORW:     0x070C6 << 15, // amor.w
	AAMORV:     0x070C7 << 15, // amor.d
	AAMXORW:    0x070C8 << 15, // amxor.w
	AAMXORV:    0x070C9 << 15, // amxor.d
	AAMMAXW:    0x070CA << 15, // ammax.w
	AAMMAXV:    0x070CB << 15, // ammax.d
	AAMMINW:    0x070CC << 15, // ammin.w
	AAMMINV:    0x070CD << 15, // ammin.d
	AAMMAXWU:   0x070CE << 15, // ammax.wu
	AAMMAXVU:   0x070CF << 15, // ammax.du
	AAMMINWU:   0x070D0 << 15, // ammin.wu
	AAMMINVU:   0x070D1 << 15, // ammin.du
	AAMSWAPDBB: 0x070BC << 15, // amswap_db.b
	AAMSWAPDBH: 0x070BD << 15, // amswap_db.h
	AAMSWAPDBW: 0x070D2 << 15, // amswap_db.w
	AAMSWAPDBV: 0x070D3 << 15, // amswap_db.d
	AAMCASDBB:  0x070B4 << 15, // amcas_db.b
	AAMCASDBH:  0x070B5 << 15, // amcas_db.h
	AAMCASDBW:  0x070B6 << 15, // amcas_db.w
	AAMCASDBV:  0x070B7 << 15, // amcas_db.d
	AAMADDDBW:  0x070D4 << 15, // amadd_db.w
	AAMADDDBV:  0x070D5 << 15, // amadd_db.d
	AAMANDDBW:  0x070D6 << 15, // amand_db.w
	AAMANDDBV:  0x070D7 << 15, // amand_db.d
	AAMORDBW:   0x070D8 << 15, // amor_db.w
	AAMORDBV:   0x070D9 << 15, // amor_db.d
	AAMXORDBW:  0x070DA << 15, // amxor_db.w
	AAMXORDBV:  0x070DB << 15, // amxor_db.d
	AAMMAXDBW:  0x070DC << 15, // ammax_db.w
	AAMMAXDBV:  0x070DD << 15, // ammax_db.d
	AAMMINDBW:  0x070DE << 15, // ammin_db.w
	AAMMINDBV:  0x070DF << 15, // ammin_db.d
	AAMMAXDBWU: 0x070E0 << 15, // ammax_db.wu
	AAMMAXDBVU: 0x070E1 << 15, // ammax_db.du
	AAMMINDBWU: 0x070E2 << 15, // ammin_db.wu
	AAMMINDBVU: 0x070E3 << 15, // ammin_db.du
}

func (c *ctxt0) specialFpMovInst(a obj.As, fclass int, tclass int) uint32 {
	switch a {
	case AMOVV:
		switch fclass {
		case C_REG:
			switch tclass {
			case C_FREG:
				return 0x452a << 10 // movgr2fr.d
			case C_FCCREG:
				return 0x4536 << 10 // movgr2cf
			case C_FCSRREG:
				return 0x4530 << 10 // movgr2fcsr
			}
		case C_FREG:
			switch tclass {
			case C_REG:
				return 0x452e << 10 // movfr2gr.d
			case C_FCCREG:
				return 0x4534 << 10 // movfr2cf
			}
		case C_FCCREG:
			switch tclass {
			case C_REG:
				return 0x4537 << 10 // movcf2gr
			case C_FREG:
				return 0x4535 << 10 // movcf2fr
			}
		case C_FCSRREG:
			switch tclass {
			case C_REG:
				return 0x4532 << 10 // movfcsr2gr
			}
		}

	case AMOVW:
		switch fclass {
		case C_REG:
			switch tclass {
			case C_FREG:
				return 0x4529 << 10 // movgr2fr.w
			}
		case C_FREG:
			switch tclass {
			case C_REG:
				return 0x452d << 10 // movfr2gr.s
			}
		}
	}

	c.ctxt.Diag("bad class combination: %s %d,%d\n", a, fclass, tclass)

	return 0
}

func (c *ctxt0) specialLsxMovInst(a obj.As, fReg, tReg int16, offset_flag bool) (op_code, index_mask uint32) {
	farng := (fReg >> EXT_TYPE_SHIFT) & EXT_TYPE_MASK
	tarng := (tReg >> EXT_TYPE_SHIFT) & EXT_TYPE_MASK
	fclass := c.rclass(fReg)
	tclass := c.rclass(tReg)

	switch fclass | (tclass << 16) {
	case C_REG | (C_ELEM << 16):
		// vmov Rn, Vd.<T>[index]
		switch a {
		case AVMOVQ:
			switch tarng {
			case ARNG_B:
				return (0x01CBAE << 14), 0xf // vinsgr2vr.b
			case ARNG_H:
				return (0x03975E << 13), 0x7 // vinsgr2vr.h
			case ARNG_W:
				return (0x072EBE << 12), 0x3 // vinsgr2vr.w
			case ARNG_V:
				return (0x0E5D7E << 11), 0x1 // vinsgr2vr.d
			}
		case AXVMOVQ:
			switch tarng {
			case ARNG_W:
				return (0x03B75E << 13), 0x7 // xvinsgr2vr.w
			case ARNG_V:
				return (0x076EBE << 12), 0x3 // xvinsgr2vr.d
			}
		}

	case C_ELEM | (C_REG << 16):
		// vmov Vd.<T>[index], Rn
		switch a {
		case AVMOVQ:
			switch farng {
			case ARNG_B:
				return (0x01CBBE << 14), 0xf // vpickve2gr.b
			case ARNG_H:
				return (0x03977E << 13), 0x7 // vpickve2gr.h
			case ARNG_W:
				return (0x072EFE << 12), 0x3 // vpickve2gr.w
			case ARNG_V:
				return (0x0E5DFE << 11), 0x1 // vpickve2gr.d
			case ARNG_BU:
				return (0x01CBCE << 14), 0xf // vpickve2gr.bu
			case ARNG_HU:
				return (0x03979E << 13), 0x7 // vpickve2gr.hu
			case ARNG_WU:
				return (0x072F3E << 12), 0x3 // vpickve2gr.wu
			case ARNG_VU:
				return (0x0E5E7E << 11), 0x1 // vpickve2gr.du
			}
		case AXVMOVQ:
			switch farng {
			case ARNG_W:
				return (0x03B77E << 13), 0x7 // xvpickve2gr.w
			case ARNG_V:
				return (0x076EFE << 12), 0x3 // xvpickve2gr.d
			case ARNG_WU:
				return (0x03B79E << 13), 0x7 // xvpickve2gr.wu
			case ARNG_VU:
				return (0x076F3E << 12), 0x3 // xvpickve2gr.du
			}
		}

	case C_REG | (C_ARNG << 16):
		switch {
		case offset_flag:
			// vmov offset(vj), vd.<T>
			switch a {
			case AVMOVQ:
				switch tarng {
				case ARNG_16B:
					return (0xC2 << 22), 0x0 // vldrepl.b
				case ARNG_8H:
					return (0x182 << 21), 0x0 // vldrepl.h
				case ARNG_4W:
					return (0x302 << 20), 0x0 // vldrepl.w
				case ARNG_2V:
					return (0x602 << 19), 0x0 // vldrepl.d
				}
			case AXVMOVQ:
				switch tarng {
				case ARNG_32B:
					return (0xCA << 22), 0x0 // xvldrepl.b
				case ARNG_16H:
					return (0x192 << 21), 0x0 // xvldrepl.h
				case ARNG_8W:
					return (0x322 << 20), 0x0 // xvldrepl.w
				case ARNG_4V:
					return (0x642 << 19), 0x0 // xvldrepl.d
				}
			}
		default:
			// vmov Rn, Vd.<T>
			switch a {
			case AVMOVQ:
				switch tarng {
				case ARNG_16B:
					return (0x1CA7C0 << 10), 0x0 // vreplgr2vr.b
				case ARNG_8H:
					return (0x1CA7C1 << 10), 0x0 // vreplgr2vr.h
				case ARNG_4W:
					return (0x1CA7C2 << 10), 0x0 // vreplgr2vr.w
				case ARNG_2V:
					return (0x1CA7C3 << 10), 0x0 // vreplgr2vr.d
				}
			case AXVMOVQ:
				switch tarng {
				case ARNG_32B:
					return (0x1DA7C0 << 10), 0x0 // xvreplgr2vr.b
				case ARNG_16H:
					return (0x1DA7C1 << 10), 0x0 // xvreplgr2vr.h
				case ARNG_8W:
					return (0x1DA7C2 << 10), 0x0 // xvreplgr2vr.w
				case ARNG_4V:
					return (0x1DA7C3 << 10), 0x0 // xvreplgr2vr.d
				}
			}
		}

	case C_XREG | (C_ARNG << 16):
		// vmov  xj, xd.<T>
		switch a {
		case AVMOVQ:
			return 0, 0 // unsupported op
		case AXVMOVQ:
			switch tarng {
			case ARNG_32B:
				return (0x1DC1C0 << 10), 0x0 // xvreplve0.b
			case ARNG_16H:
				return (0x1DC1E0 << 10), 0x0 // xvreplve0.h
			case ARNG_8W:
				return (0x1DC1F0 << 10), 0x0 // xvreplve0.w
			case ARNG_4V:
				return (0x1DC1F8 << 10), 0x0 // xvreplve0.d
			case ARNG_2Q:
				return (0x1DC1FC << 10), 0x0 // xvreplve0.q
			}
		}

	case C_XREG | (C_ELEM << 16):
		// vmov  xj, xd.<T>[index]
		switch a {
		case AVMOVQ:
			return 0, 0 // unsupported op
		case AXVMOVQ:
			switch tarng {
			case ARNG_W:
				return (0x03B7FE << 13), 0x7 // xvinsve0.w
			case ARNG_V:
				return (0x076FFE << 12), 0x3 // xvinsve0.d
			}
		}

	case C_ELEM | (C_XREG << 16):
		// vmov  xj.<T>[index], xd
		switch a {
		case AVMOVQ:
			return 0, 0 // unsupported op
		case AXVMOVQ:
			switch farng {
			case ARNG_W:
				return (0x03B81E << 13), 0x7 // xvpickve.w
			case ARNG_V:
				return (0x07703E << 12), 0x3 // xvpickve.d
			}
		}

	case C_ELEM | (C_ARNG << 16):
		// vmov  vj.<T>[index], vd.<T>
		switch a {
		case AVMOVQ:
			switch int32(farng) | (int32(tarng) << 16) {
			case int32(ARNG_B) | (int32(ARNG_16B) << 16):
				return (0x01CBDE << 14), 0xf // vreplvei.b
			case int32(ARNG_H) | (int32(ARNG_8H) << 16):
				return (0x0397BE << 13), 0x7 // vreplvei.h
			case int32(ARNG_W) | (int32(ARNG_4W) << 16):
				return (0x072F7E << 12), 0x3 // vreplvei.w
			case int32(ARNG_V) | (int32(ARNG_2V) << 16):
				return (0x0E5EFE << 11), 0x1 // vreplvei.d
			}
		case AXVMOVQ:
			return 0, 0 // unsupported op
		}
	}

	return 0, 0
}
