a=Add (32)
ad=Add Normalized (LH)
adb=Add (LB)
adbr=Add (LB)
adr=Add Normalized (LH)
adtr=Add (LD)
adtra=ADD (LD)
ae=Add Normalized (SH)
aeb=Add (SB)
aebr=Add (SB)
aer=Add Normalized (SH)
afi=Add Immediate (32)
ag=Add (64)
agf=Add (64\32)
agfi=Add Immediate (64\32)
agfr=Add (64\32)
aghi=Add Halfword Immediate (64\16)
aghik=Add Immediate (64\16)
agr=Add (64)
agrk=Add (64)
agsi=Add Immediate (64\8)
ah=Add Halfword (32\16)
ahhhr=Add High (32)
ahhlr=Add High (32)
ahi=Add Halfword Immediate (32\16)
ahik=Add Immediate (32\16)
ahy=Add Halfword (32\16)
aih=Add Immediate High (32)
al=Add Logical (32)
alc=Add Logical with Carry (32)
alcg=Add Logical with Carry (64)
alcgr=Add Logical with Carry (64)
alcr=Add Logical with Carry (32)
alfi=Add Logical Immediate (32)
alg=Add Logical (64)
algf=Add Logical (64\32)
algfi=Add Logical Immediate (64\32)
algfr=Add Logical (64\32)
alghsik=Add Logical with Signed Immediate
algr=Add Logical (64)
algrk=Add Logical (64)
algsi=Add Logical with Signed Immediate (64\8)
alhhhr=Add Logical High (32)
alhhlr=Add Logical High (32)
alhsik=Add Logical with Signed Immediate
alr=Add Logical (32)
alrk=Add Logical (32)
alsi=Add Logical with Signed Immediate (32\8)
alsih=Add Logical with Signed Immediate High
alsihn=Add Logical with Signed Immediate High
aly=Add Logical (32)
ap=Add Decimal
ar=Add (32)
ark=Add (32)
asi=Add Immediate (32\8)
au=Add Unnormalized (SH)
aur=Add Unnormalized (SH)
aw=Add Unnormalized (LH)
awr=Add Unnormalized (LH)
axbr=Add (EB)
axr=Add Normalized (EH)
axtr=Add (ED)
axtra=ADD (ED)
ay=Add (32)
bakr=Branch and Stack
bal=Branch and Link
balr=Branch and Link
bas=Branch and Save
basr=Branch and Save
bassm=Branch and Save and Set Mode
bc=Branch on Condition
br=Branch on Condition
bcr=Branch on Condition
bct=Branch on Count (32)
bctg=Branch on Count (64)
bctgr=Branch on Count (64)
bctr=Branch on Count (32)
bpp=Branch Prediction Preload
bprp=Branch Prediction Relative Preload
bras=Branch Relative and Save
brasl=Branch Relative and Save Long
brc=Branch Relative on Condition
brcl=Branch Relative on Condition Long
brct=Branch Relative on Count (32)
brctg=Branch Relative on Count (64)
brcth=Branch Relative on Count High (32)
brxh=Branch Relative on Index High (32)
brxhg=Branch Relative on Index High (64)
brxle=Branch Relative on Index Low or Equal (32)
brxlg=Branch Relative on Index Low or Equal (64)
bsa=Branch and Set Authority
bsg=Branch in Subspace Group
bsm=Branch and Set Mode
bxh=Branch on Index High (32)
bxhg=Branch on Index High (64)
bxle=Branch on Index Low or Equal (32)
bxleg=Branch on Index Low or Equal (64)
c=Compare (32)
cd=Compare (LH)
cdb=Compare (LB)
cdbr=Compare (LB)
cdfbr=Convert from Fixed (LB\32)
cdfbra=Convert from Fixed (LB\32)
cdfr=Convert from Fixed (LH\32)
cdftr=Convert from Fixed (LD\32)
cdgbr=Convert from Fixed (LB\64)
cdgbra=Convert from Fixed (LB\64)
cdgr=Convert from Fixed (LH\64)
cdgtr=Convert from Fixed (LD\64)
cdgtra=Convert from Fixed (LD\64)
cdlfbr=Convert from Logical (LB\32)
cdlftr=Convert from Logical (LD\32)
cdlgbr=Convert from Logical (LB\64)
cdlgtr=Convert from Logical (LD\64)
cdpt=Convert from Packed (To Long DFP)
cdr=Compare (LH)
cds=Compare Double and Swap (32)
cdsg=Compare Double and Swap (64)
cdstr=Convert from Signed Packed (LD\64)
cdsy=Compare Double and Swap (32)
cdtr=Compare (LD)
cdutr=Convert from Unsigned Packed (LD\64)
cdzt=Comvert from Zoned (to long DFP)
ce=Compare (SH)
ceb=Compare (SB)
cebr=Compare (SB)
cedtr=Compare Biased Exponent (LD)
cefbr=Convert from Fixed (SB\32)
cefbra=Convert from Fixed (SB\32)
cefr=Convert from Fixed (SH\32)
cegbr=Convert from Fixed (SB\64)
cegbra=Convert from Fixed (SB\64)
cegr=Convert from Fixed (SH\64)
celfbr=Convert from Logical (SB\32)
celgbr=Convert from Logical (SB\64)
cer=Compare (SH)
cextr=Compare Biased Exponent (ED)
cfc=Compare and Form Codeword
cfdbr=Convert to Fixed (32\LB)
cfdbra=Convert to Fixed (32\LB)
cfdr=Convert to Fixed (32\LH)
cfdtr=Convert to Fixed (32\LD)
cfebr=Convert to Fixed (32\SB)
cfebra=Convert to Fixed (32\SB)
cfer=Convert to Fixed (32\SH)
cfi=Compare Immediate (32)
cfxbr=Convert to Fixed (32\EB)
cfxbra=Convert to Fixed (32\EB)
cfxr=Convert to Fixed (32\EH)
cfxtr=Convert to Fixed (32\ED)
cg=Compare (64)
cgdbr=Convert to Fixed (64\LB)
cgdbra=Convert to Fixed (64\LB)
cgdr=Convert to Fixed (64\LH)
cgdtr=Convert to Fixed (64\LD)
cgdtra=Convert to Fixed (64\LD)
cgebr=Convert to Fixed (64\SB)
cgebra=Convert to Fixed (64\SB)
cger=Convert to Fixed (64\SH)
cgf=Compare (64\32)
cgfi=Compare Immediate (64\32)
cgfr=Compare (64\32)
cgfrl=Compare Relative Long (64\32)
cgh=Compare Halfword (64\16)
cghi=Compare Halfword Immediate (64\16)
cghrl=Compare Halfword Relative Long (64\16)
cghsi=Compare Halfword Immediate (64\16)
cgib=Compare Immediate and Branch (64\8)
cgij=Compare Immediate and Branch Relative
cgit=Compare Immediate and Trap (64\16)
cgr=Compare (64)
cgrb=Compare and Branch (64)
cgrj=Compare and Branch Relative (64)
cgrl=Compare Relative Long (64)
cgrt=Compare and Trap (64)
cgxbr=Convert to Fixed (64\EB)
cgxbra=Convert to Fixed (64\EB)
cgxr=Convert to Fixed (64\EH)
cgxtr=Convert to Fixed (64\ED)
cgxtra=Convert to Fixed (64\ED)
ch=Compare Halfword (32\16)
chf=Compare High (32)
chhr=Compare High (32)
chhsi=Compare Halfword Immediate (16\16)
chi=Compare Halfword Immediate (32\16)
chlr=Compare High (32)
chrl=Compare Halfword Relative Long (32\16)
chsi=Compare Halfword Immediate (32\16)
chy=Compare Halfword (32\16)
cib=Compare Immediate and Branch (32\8)
cih=Compare Immediate High (32)
cij=Compare Immediate and Branch Relative
cit=Compare Immediate and Trap (32\16)
cksm=Checksum
cl=Compare Logical (32)
clc=Compare Logical (character)
clcl=Compare Logical Long
clcle=Compare Logical Long Extended
clclu=Compare Logical Long Unicode
clfdbr=Convert to Logical (32\LB)
clfdtr=Convert to Logical (32\LD)
clfebr=Convert to Logical (32\SB)
clfhsi=Compare Logical Immediate (32\16)
clfi=Compare Logical Immediate (32)
clfit=Compare Logical Immediate and Trap
clfxbr=Convert to Logical (32\EB)
clfxtr=Convert to Logical (32\ED)
clg=Compare Logical (64)
clgdbr=Convert to Logical (64\LB)
clgdtr=Convert to Logical (64\LD)
clgebr=Convert to Logical (64\SB)
clgf=Compare Logical (64\32)
clgfi=Compare Logical Immediate (64\32)
clgfr=Compare Logical (64\32)
clgfrl=Compare Logical Relative Long (64\32)
clghrl=Compare Logical Relative Long (64\16)
clghsi=Compare Logical Immediate (64\16)
clgib=Compare Logical Immediate and Branch
clgij=Compare Logical Immediate and Branch
clgit=Compare Logical Immedical and Trap
clgr=Compare Logical (64)
clgrb=Compare Logical and Branch (64)
clgrj=Compare Logical and Branch Relative (64
clgrl=Compare Logical Relative Long (64)
clgrt=Compare Logical and Trap (64)
clgt=Compare Logical and Trap (64)
clgxbr=Convert to Logical (64\EB)
clgxtr=Convert to Logical (64\ED)
clhf=Compare Logical High (32)
clhhr=Compare Logical High (32)
clhhsi=Compare Logical Immediate (16\16)
clhlr=Compare Logical High (32)
clhrl=Compare Logical Relative Long (32\16)
cli=Compare Logical Immediate
clib=Compare Logical Immediate and Branch
clih=Compare Logical Immediate High (32)
clij=Compare Logical Immediate and Branch
cliy=Compare Logical Immediate
clm=Compare Logical Char. under Mask (low)
clmh=Compare Logical Char. under Mask (high)
clmy=Compare Logical Char. under Mask (low)
clr=Compare Logical (32)
clrb=Compare Logical and Branch (32)
clrj=Compare Logical and Branch Relative (32)
clrl=Compare Logical Relative Long (32)
clrt=Compare Logical and Trap (32)
clst=Compare Logical String
clt=Compare Logical and Trap (32)
cly=Compare Logical (32)
cmpsc=Compression Call
cp=Compare Decimal
cpdt=Convert to Packed (From Long DFP)
cpsdr=Copy Sign (L)
cpxt=Convert to Packed (From Extended DFP)
cpya=Copy Access
cr=Compare (32)
crb=Compare and Branch (32)
crdte=Compare and Replace DAT Table Entry
crj=Compare and Branch Relative (32)
crl=Compare Relative Long (32)
crt=Compare and Trap (32)
cs=Compare and Swap (32)
csch=Clear Subchannel
csdtr=Convert to Signed Packed (64\LD)
csg=Compare and Swap (64)
csp=Compare and Swap and Purge (32)
cspg=Compare and Swap and Purge (64)
csst=Compare and Swap and Store
csxtr=Convert to Signed Packed (128\ED)
csy=Compare and Swap (32)
cu12=Convert UTF-8 to UTF-16
cu14=Convert UTF-8 to UTF-32
cu21=Convert UTF-16 to UTF-8
cu24=Convert UTF-16 to UTF-32
cu41=Convert UTF-32 to UTF-8
cu42=Convert UTF-32 to UTF-16
cudtr=Convert to Unsigned Packed (64\LD)
cuse=Compare until Substring Equal
cutfu=Convert UTF-8 to Unicode
cuutf=Convert Unicode to UTF-8
cuxtr=Convert to Unsigned Packed (128\ED)
cvb=Convert to Binary (32)
cvbg=Convert to Binary (64)
cvby=Convert to Binary (32)
cvd=Convert to Decimal (32)
cvdg=Convert to Decimal (64)
cvdy=Convert to Decimal (32)
cxbr=Compare (EB)
cxfbr=Convert from Fixed (EB\32)
cxfbra=Convert from Fixed (EB\32)
cxfr=Convert from Fixed (EH\32)
cxftr=Convert from Fixed (ED\32)
cxgbr=Convert from Fixed (EB\64)
cxgbra=Convert from Fixed (EB\64)
cxgr=Convert from Fixed (EH\64)
cxgtr=Convert from Fixed (ED\64)
cxgtra=Convert from Fixed (ED\64)
cxlfbr=Convert from Logical (EB\32)
cxlftr=Convert from Logical (ED\32)
cxlgbr=Convert from Logical (EB\64)
cxlgtr=Convert from Logical (ED\64)
cxpt=Convert from Packed (To Extended DFP
cxr=Compare (EH)
cxstr=Convert from Signed Packed (ED\128)
cxtr=Compare (ED)
cxutr=Convert from Unsigned Packed (ED\128
cxzt=Comvert from Zoned (to extended DFP)
cy=Compare (32)
czdt=Comvert to Zoned (from long DFP)
czxt=Comvert to Zoned (from extended DFP)
d=Divide (32\64)
dd=Divide (LH)
ddb=Divide (LB)
ddbr=Divide (LB)
ddr=Divide (LH)
ddtr=Divide (LD)
ddtra=Divide (LD)
de=Divide (SH)
deb=Divide (SB)
debr=Divide (SB)
der=Divide (SH)
didbr=Divide to Integer (LB)
diebr=Divide to Integer (SB)
dl=Divide Logical (32\64)
dlg=Divide Logical (64\128)
dlgr=Divide Logical (64\128)
dlr=Divide Logical (32\64)
dp=Divide Decimal
dr=Divide (32\64)
dsg=Divide Single (64)
dsgf=Divide Single (64\32)
dsgfr=Divide Single (64\32)
dsgr=Divide Single (64)
dxbr=Divide (EB)
dxr=Divide (EH)
dxtr=Divide (ED)
dxtra=Divide (ED)
ear=Extract Access
ecag=Extract CPU Attribute
ectg=Extract CPU Time
ed=Edit
edmk=Edit and Mark
eedtr=Extract Biased Exponent (64\LD)
eextr=Extract Biased Exponent (64\ED)
efpc=Extract FPC
epair=Extract Primary ASN and Instance
epar=Extract Primary ASN
epsw=Extract PSW
ereg=Extract Stacked Registers (32)
eregg=Extract Stacked Registers (64)
esair=Extract Secondary ASN and Instance
esar=Extract Secondary ASN
esdtr=Extract Significance (64\LD)
esea=Extract and Set Extended Authority
esta=Extract Stacked State
esxtr=Extract Significance (64\ED)
etnd=Extract Transaction Nesting Depth
ex=Execute
exrl=Execute Relative Long
fidbr=Load FP Integer (LB)
fidbra=Load FP Integer (LB)
fidr=Load FP Integer (LH)
fidtr=Load FP Integer (LD)
fiebr=Load FP Integer (SB)
fiebra=Load FP Integer (SB)
fier=Load FP Integer (SH)
fixbr=Load FP Integer (EB)
fixbra=Load FP Integer (EB)
fixr=Load FP Integer (EH)
fixtr=Load FP Integer (ED)
flogr=Find Leftmost One
hdr=Halve (LH)
her=Halve (SH)
hsch=Halt Subchannel
iac=Insert Address Space Control
ic=Insert Character
icm=Insert Characters under Mask (low)
icmh=Insert Characters under Mask (high)
icmy=Insert Characters under Mask (low)
icy=Insert Character
idte=Invalidate DAT Table Entry
iedtr=Insert Biased Exponent (LD\64&LD)
iextr=Insert Biased Exponent (ED\64&ED)
iihf=Insert Immediate (high)
iihh=Insert Immediate (high high)
iihl=Insert Immediate (high low)
iilf=Insert Immediate (low)
iilh=Insert Immediate (low high)
iill=Insert Immediate (low low)
ipk=Insert PSW Key
ipm=Insert Program Mask
ipte=Invalidate Page Table Entry
iske=Insert Storage Key Extended
ivsk=Insert Virtual Storage Key
kdb=Compare and Signal (LB)
kdbr=Compare and Signal (LB)
kdtr=Compare and Signal (LD)
keb=Compare and Signal (SB)
kebr=Compare and Signal (SB)
kimd=Compute Intermediate Message Digest
klmd=Compute Last Message Digest
km=Cipher Message
kmac=Compute Message Authentication Code
kmc=Cipher Message with Chaining
kmctr=Cipher Message with Counter
kmf=Cipher Message with Cipher Feedback
kmo=Cipher Message with Output Feedback
kxbr=Compare and Signal (EB)
kxtr=Compare and Signal (ED)
l=Load (32)
la=Load Address
laa=Load and Add (32)
laag=Load and Add (64)
laal=Load and Add Logical (32)
laalg=Load and Add Logical (64)
lae=Load Address Extended
laey=Load Address Extended
lam=Load Access Multiple
lamy=Load Access Multiple
lan=Load and AND (32)
lang=Load and AND (64)
lao=Load and OR (32)
laog=Load and OR (64)
larl=Load Address Relative Long
lasp=Load Address Space Parameters
lat=Load and Trap (32)
lax=Load and Exclusive OR (32)
laxg=Load and Exclusive OR (64)
lay=Load Address
lb=Load Byte (32\8)
lbh=Load Byte High (32\8)
lbr=Load Byte (32\8)
lcbb=Load Count to Block Boundary
lcdbr=Load Complement (LB)
lcdfr=Load Complement (L)
lcdr=Load Complement (LH)
lcebr=Load Complement (SB)
lcer=Load Complement (SH)
lcgfr=Load Complement (64\32)
lcgr=Load Complement (64)
lcr=Load Complement (32)
lctl=Load Control (32)
lctlg=Load Control (64)
lcxbr=Load Complement (EB)
lcxr=Load Complement (EH)
ld=Load (L)
lde=Load Lengthened (LH\SH)
ldeb=Load Lengthened (LB\SB)
ldebr=Load Lengthened (LB\SB)
lder=Load Lengthened (LH\SH)
ldetr=Load Lengthened (LD\SD)
ldgr=Load FPR from GR (L\64)
ldr=Load (L)
ldxbr=Load Rounded (LB\EB)
ldxbra=Load Rounded (LB\EB)
ldxr=Load Rounded (LH\EH)
ldxtr=Load Rounded (LD\ED)
ldy=Load (L)
le=Load (S)
ledbr=Load Rounded (SB\LB)
ledbra=Load Rounded (SB\LB)
ledr=Load Rounded (SH\LH)
ledtr=Load Rounded (SD\LD)
ler=Load (S)
lexbr=Load Rounded (SB\EB)
lexbra=Load Rounded (SB\EB)
lexr=Load Rounded (SH\EH)
ley=Load (S)
lfas=Load FPC and Signal
lfh=Load High (32)
lfhat=Load and Trap (32H\32)
lfpc=Load FPC
lg=Load (64)
lgat=Load and Trap (64)
lgb=Load Byte (64\8)
lgbr=Load Byte (64\8)
lgdr=Load GR from FPR (64\L)
lgf=Load (64\32)
lgfi=Load Immediate (64\32)
lgfr=Load (64\32)
lgfrl=Load Relative Long (64\32)
lgh=Load Halfword (64\16)
lghi=Load Halfword Immediate (64\16)
lghr=Load Halfword (64\16)
lghrl=Load Halfword Relative Long (64\16)
lgr=Load (64)
lgrl=Load Relative Long (64)
lh=Load Halfword (32\16)
lhh=Load Halfword High (32\16)
lhi=Load Halfword Immediate (32\16)
lhr=Load Halfword (32\16)
lhrl=Load Halfword Relative Long (32\16)
lhy=Load Halfword (32\16)
llc=Load Logical Character (32\8)
llch=Load Logical Character High (32\8)
llcr=Load Logical Character (32\8)
llgc=Load Logical Character (64\8)
llgcr=Load Logical Character (64\8)
llgf=Load Logical (64\32)
llgfat=Load and Trap (64\32)
llgfr=Load Logical (64\32)
llgfrl=Load Logical Relative Long (64\32)
llgh=Load Logical Halfword (64\16)
llghr=Load Logical Halfword (64\16)
llghrl=Load Logical Halfword Relative Long
llgt=Load Logical Thirty One Bits (64\31)
llgtat=Load Logical Thirty One Bits and Trap
llgtr=Load Logical Thirty One Bits (64\31)
llh=Load Logical Halfword (32\16)
llhh=Load Logical Halfword High (32\16)
llhr=Load Logical Halfword (32\16)
llhrl=Load Logical Halfword Relative Long
llihf=Load Logical Immediate (high)
llihh=Load Logical Immediate (high high)
llihl=Load Logical Immediate (high low)
llilf=Load Logical Immediate (low)
llilh=Load Logical Immediate (low high)
llill=Load Logical Immediate (low low)
llzrgf=Load Logical and Zero Rightmost Byte (32)
lm=Load Multiple (32)
lmd=Load Multiple Disjoint (64\32&32)
lmg=Load Multiple (64)
lmh=Load Multiple High
lmy=Load Multiple (32)
lndbr=Load Negative (LB)
lndfr=Load Negative (L)
lndr=Load Negative (LH)
lnebr=Load Negative (SB)
lner=Load Negative (SH)
lngfr=Load Negative (64\32)
lngr=Load Negative (64)
lnr=Load Negative (32)
lnxbr=Load Negative (EB)
lnxr=Load Negative (EH)
loc=Load on Condition (32)
locfh=Load High on Condition (32)
locfhr=Load High on Condition (32)
locg=Load on Condition (64)
locghi=Load Halfword Immediate on Condition
locgr=Load on Condition (64)
lochhi=Load Halfword High Immediate on Condi-
lochi=Load Halfword Immediate on Condition
locr=Load on Condition (32)
lpd=Load Pair Disjoint (32)
lpdbr=Load Positive (LB)
lpdfr=Load Positive (L)
lpdg=Load Pair Disjoint (64)
lpdr=Load Positive (LH)
lpebr=Load Positive (SB)
lper=Load Positive (SH)
lpgfr=Load Positive (64\32)
lpgr=Load Positive (64)
lpq=Load Pair from Quadword (64&64\128)
lpr=Load Positive (32)
lpsw=Load PSW
lpswe=Load PSW Extended
lptea=Load Page-Table-Entry Address
lpxbr=Load Positive (EB)
lpxr=Load Positive (EH)
lr=Load (32)
lra=Load Real Address (32)
lrag=Load Real Address (64)
lray=Load Real Address (32)
lrdr=Load Rounded (LH\EH)
lrer=Load Rounded (SH\LH)
lrl=Load Relative Long (32)
lrv=Load Reversed (32)
lrvg=Load Reversed (64)
lrvgr=Load Reversed (64)
lrvh=Load Reversed (16)
lrvr=Load Reversed (32)
lt=Load and Test (32)
ltdbr=Load and Test (LB)
ltdr=Load and Test (LH)
ltdtr=Load and Test (LD)
ltebr=Load and Test (SB)
lter=Load and Test (SH)
ltg=Load and Test (64)
ltgf=Load And Test (64\32)
ltgfr=Load and Test (64\32)
ltgr=Load and Test (64)
ltr=Load and Test (32)
ltxbr=Load and Test (EB)
ltxr=Load and Test (EH)
ltxtr=Load and Test (ED)
lura=Load Using Real Address (32)
lurag=Load Using Real Address (64)
lxd=Load Lengthened (EH\LH)
lxdb=Load Lengthened (EB\LB)
lxdbr=Load Lengthened (EB\LB)
lxdr=Load Lengthened (EH\LH)
lxdtr=Load Lengthened (ED\LD)
lxe=Load Lengthened (EH\SH)
lxeb=Load Lengthened (EB\SB)
lxebr=Load Lengthened (EB\SB)
lxer=Load Lengthened (EH\SH)
lxr=Load (E)
ly=Load (32)
lzdr=Load Zero (L)
lzer=Load Zero (S)
lzrf=Load and Zero Rightmost Byte (32)
lzrg=Load and Zero Rightmost Byte (64)
lzxr=Load Zero (E)
m=Multiply (64\32)
mad=Multiply and Add (LH)
madb=Multiply and Add (LB)
madbr=Multiply and Add (LB)
madr=Multiply and Add (LH)
mae=Multiply and Add (SH)
maeb=Multiply and Add (SB)
maebr=Multiply and Add (SB)
maer=Multiply and Add (SH)
may=Multiply and Add Unnormalized (EH\LH)
mayh=Multiply and Add Unnormalized (EHH\LH)
mayhr=Multiply and Add Unnormalized (EHH\LH)
mayl=Multiply and Add Unnormalized (EHL\LH)
maylr=Multiply and Add Unnormalized (EHL\LH)
mayr=Multiply and Add Unnormalized (EH\LH)
mc=Monitor Call
md=Multiply (LH)
mdb=Multiply (LB)
mdbr=Multiply (LB)
mde=Multiply (LH\SH)
mdeb=Multiply (LB\SB)
mdebr=Multiply (LB\SB)
mder=Multiply (LH\SH)
mdr=Multiply (LH)
mdtr=Multiply (LD)
mdtra=Multiply (LD)
me=Multiply (LH\SH)
mee=Multiply (SH)
meeb=Multiply (SB)
meebr=Multiply (SB)
meer=Multiply (SH)
mer=Multiply (LH\SH)
mfy=Multiply (64\32)
mghi=Multiply Halfword Immediate (64\16)
mh=Multiply Halfword (32\16)
mhi=Multiply Halfword Immediate (32\16)
mhy=Multiply Halfword (64\16)
ml=Multiply Logical (64\32)
mlg=Multiply Logical (128\64)
mlgr=Multiply Logical (128\64)
mlr=Multiply Logical (64\32)
mp=Multiply Decimal
mr=Multiply (64\32)
ms=Multiply Single (32)
msch=Modify Subchannel
msd=Multiply and Subtract (LH)
msdb=Multiply and Subtract (LB)
msdbr=Multiply and Subtract (LB)
msdr=Multiply and Subtract (LH)
mse=Multiply and Subtract (SH)
mseb=Multiply and Subtract (SB)
msebr=Multiply and Subtract (SB)
mser=Multiply and Subtract (SH)
msfi=Multiply Single Immediate (32)
msg=Multiply Single (64)
msgf=Multiply Single (64\32)
msgfi=Multiply Single Immediate (64\32)
msgfr=Multiply Single (64\32)
msgr=Multiply Single (64)
msr=Multiply Single (32)
msta=Modify Stacked State
msy=Multiply Single (32)
mvc=Move (character)
mvcdk=Move with Destination Key
mvcin=Move Inverse
mvck=Move with Key
mvcl=Move Long
mvcle=Move Long Extended
mvclu=Move Long Unicode
mvcos=Move with Optional Specifications
mvcp=Move to Primary
mvcs=Move to Secondary
mvcsk=Move with Source Key
mvghi=Move (64\16)
mvhhi=Move (16\16)
mvhi=Move (32\16)
mvi=Move Immediate
mviy=Move Immediate
mvn=Move Numerics
mvo=Move with Offset
mvpg=Move Page
mvst=Move String
mvz=Move Zones
mxbr=Multiply (EB)
mxd=Multiply (EH\LH)
mxdb=Multiply (EB\LB)
mxdbr=Multiply (EB\LB)
mxdr=Multiply (EH\LH)
mxr=Multiply (EH)
mxtr=Multiply (ED)
mxtra=Multiply (ED)
my=Multiply Unnormalized (EH\LH)
myh=Multiply Unnormalized (EHH\LH)
myhr=Multiply Unnormalized (EHH\LH)
myl=Multiply Unnormalized (EHL\LH)
mylr=Multiply Unnormalized (EHL\LH)
myr=Multiply Unnormalized (EH\LH)
n=AND (32)
nc=AND (character)
ng=AND (64)
ngr=AND (64)
ngrk=AND (64)
ni=AND Immediate
niai=Next Instruction Access Intent
nihf=AND Immediate (high)
nihh=AND Immediate (high high)
nihl=AND Immediate (high low)
nilf=AND Immediate (low)
nilh=AND Immediate (low high)
nill=AND Immediate (low low)
niy=AND Immediate
nr=AND (32)
nrk=AND (32)
ntstg=Nontransactional Store (64)
ny=AND (32)
o=OR (32)
oc=OR (character)
og=OR (64)
ogr=OR (64)
ogrk=OR (64)
oi=OR Immediate
oihf=OR Immediate (high)
oihh=OR Immediate (high high)
oihl=OR Immediate (high low)
oilf=OR Immediate (low)
oilh=OR Immediate (low high)
oill=OR Immediate (low low)
oiy=OR Immediate
or=OR (32)
ork=OR (32)
oy=OR (32)
pack=Pack
palb=Purge ALB
pc=Program Call
pcc=Perform Cryptographic Computation
pckmo=Perform Crypto. Key Mgmt. Operations
pfd=Prefetch Data
pfdrl=Prefetch Data Relative Long
pfmf=Perform Frame Management Function
pfpo=Perform Floating-Point Operation
pgin=Page In
pgout=Page Out
pka=Pack ASCII
pku=Pack Unicode
plo=Perform Locked Operation
popcnt=Population Count
ppa=Perform Processor Assist
ppno=Perform Pseudorandom Number Operation
pr=Program Return
pt=Program Transfer
ptf=Perform Topology Function
ptff=Perform Timing-Facility Function
pti=Program Transfer with Instance
ptlb=Purge TLB
qadtr=Quantize (LD)
qaxtr=Quantize (ED)
rchp=Reset Channel Path
risbg=Rotate then Insert Selected Bits (64)
risbgn=Rotate then Insert Selected Bits (64)
risbhg=Rotate then Insert Selected Bits High32)
risblg=Rotate then Insert Selected Bits Low 2)
rll=Rotate Left Single Logical (32)
rllg=Rotate Left Single Logical (64)
rnsbg=Rotate then AND Selected Bits (64)
rosbg=Rotate then OR Selected Bits (64)
rp=Resume Program
rrbe=Reset Reference Bit Extended
rrbm=Reset Reference Bits Multiple
rrdtr=Reround (LD)
rrxtr=Reround (ED)
rsch=Resume Subchannel
rxsbg=Rotate then Exclusive OR Selected Bit
s=Subtract (32)
sac=Set Address Space Control
sacf=Set Address Space Control Fast
sal=Set Address Limit
sam24=Set Addressing Mode (24)
sam31=Set Addressing Mode (31)
sam64=Set Addressing Mode (64)
sar=Set Access
schm=Set Channel Monitor
sck=Set Clock
sckc=Set Clock Comparator
sckpf=Set Clock Programmable Field
sd=Subtract Normalized (LH)
sdb=Subtract (LB)
sdbr=Subtract (LB)
sdr=Subtract Normalized (LH)
sdtr=Subtract (LD)
sdtra=Subtract (LD)
se=Subtract Normalized (SH)
seb=Subtract (SB)
sebr=Subtract (SB)
ser=Subtract Normalized (SH)
sfasr=Set FPC and Signal
sfpc=Set FPC
sg=Subtract (64)
sgf=Subtract (64\32)
sgfr=Subtract (64\32)
sgr=Subtract (64)
sgrk=Subtract (64)
sh=Subtract Halfword (32\16)
shhhr=Subtract High (32)
shhlr=Subtract High (32)
shy=Subtract Halfword (32\16)
sie=Start Interpretive Execution
sigp=Signal Processor
sl=Subtract Logical (32)
sla=Shift Left Single (32)
slag=Shift Left Single (64)
slak=Shift Left Single (32)
slb=Subtract Logical with Borrow (32)
slbg=Subtract Logical with Borrow (64)
slbgr=Subtract Logical with Borrow (64)
slbr=Subtract Logical with Borrow (32)
slda=Shift Left Double (64)
sldl=Shift Left Double Logical (64)
sldt=Shift Significand Left (LD)
slfi=Subtract Logical Immediate (32)
slg=Subtract Logical (64)
slgf=Subtract Logical (64\32)
slgfi=Subtract Logical Immediate (64\32)
slgfr=Subtract Logical (64\32)
slgr=Subtract Logical (64)
slgrk=Subtract Logical (64)
slhhhr=Subtract Logical High (32)
slhhlr=Subtract Logical High (32)
sll=Shift Left Single Logical (32)
sllg=Shift Left Single Logical (64)
sllk=Shift Left Single Logical (32)
slr=Subtract Logical (32)
slrk=Subtract Logical (32)
slxt=Shift Significand Left (ED)
sly=Subtract Logical (32)
sp=Subtract Decimal
spka=Set PSW Key from Address
spm=Set Program Mask
spt=Set CPU Timer
spx=Set Prefix
sqd=Square Root (LH)
sqdb=Square Root (LB)
sqdbr=Square Root (LB)
sqdr=Square Root (LH)
sqe=Square Root (SH)
sqeb=Square Root (SB)
sqebr=Square Root (SB)
sqer=Square Root (SH)
sqxbr=Square Root (EB)
sqxr=Square Root (EH)
sr=Subtract (32)
sra=Shift Right Single (32)
srag=Shift Right Single (64)
srak=Shift Right Single (32)
srda=Shift Right Double (64)
srdl=Shift Right Double Logical (64)
srdt=Shift Significand Right (LD)
srk=Subtract (32)
srl=Shift Right Single Logical (32)
srlg=Shift Right Single Logical (64)
srlk=Shift Right Single Logical (32)
srnm=Set BFP Rounding Mode (2 bit)
srnmb=Set BFP Rounding Mode (3 bit)
srnmt=Set DFP Rounding Mode
srp=Shift and Round Decimal
srst=Search String
srstu=Search String Unicode
srxt=Shift Significand Right (ED)
ssair=Set Secondary ASN with Instance
ssar=Set Secondary ASN
ssch=Start Subchannel
sske=Set Storage Key Extended
ssm=Set System Mask
st=Store (32)
stam=Store Access Multiple
stamy=Store Access Multiple
stap=Store CPU Address
stc=Store Character
stch=Store Character High (8)
stck=Store Clock
stckc=Store Clock Comparator
stcke=Store Clock Extended
stckf=Store Clock Fast
stcm=Store Characters under Mask (low)
stcmh=Store Characters under Mask (high)
stcmy=Store Characters under Mask (low)
stcps=Store Channel Path Status
stcrw=Store Channel Report Word
stctg=Store Control (64)
stctl=Store Control (32)
stcy=Store Character
std=Store (L)
stdy=Store (L)
ste=Store (S)
stey=Store (S)
stfh=Store High (32)
stfl=Store Facility List
stfle=Store Facility List Extended
stfpc=Store FPC
stg=Store (64)
stgrl=Store Relative Long (64)
sth=Store Halfword (16)
sthh=Store Halfword High (16)
sthrl=Store Halfword Relative Long (16)
sthy=Store Halfword (16)
stidp=Store CPU ID
stm=Store Multiple (32)
stmg=Store Multiple (64)
stmh=Store Multiple High (32)
stmy=Store Multiple (32)
stnsm=Store Then And System Mask
stoc=Store on Condition (32)
stocfh=Store High on Condition (32)
stocg=Store on Condition (64)
stosm=Store Then Or System Mask
stpq=Store Pair to Quadword (64,64\128)
stpt=Store CPU Timer
stpx=Store Prefix
strag=Store Real Address (64)
strl=Store Relative Long (32)
strv=Store Reversed (32)
strvg=Store Reversed (64)
strvh=Store Reversed (16)
stsch=Store Subchannel
stsi=Store System Information
stura=Store Using Real Address (32)
sturg=Store Using Real Address (64)
sty=Store (32)
su=Subtract Unnormalized (SH)
sur=Subtract Unnormalized (SH)
svc=Supervisor Call
sw=Subtract Unnormalized (LH)
swr=Subtract Unnormalized (LH)
sxbr=Subtract (EB)
sxr=Subtract Normalized (EH)
sxtr=Subtract (ED)
sxtra=Subtract (ED)
sy=Subtract (32)
tabort=Transaction Abort
tam=Test Addressing Mode
tar=Test Access
tb=Test Block
tbdr=Convert HFP to BFP (LB\LH)
tbedr=Convert HFP to BFP (SB\LH)
tbegin=Transaction Begin (nonconstrained)
tbeginc=Transaction Begin (constrained)
tcdb=Test Data Class (LB)
tceb=Test Data Class (SB)
tcxb=Test Data Class (EB)
tdcdt=Test Data Class (LD)
tdcet=Test Data Class (SD)
tdcxt=Test Data Class (ED)
tdgdt=Test Data Group (LD)
tdget=Test Data Group (SD)
tdgxt=Test Data Group (ED)
tend=Transaction End
thder=Convert BFP to HFP (LH\SB)
thdr=Convert BFP to HFP (LH\LB)
tm=Test under Mask
tmh=Test under Mask High
tmhh=Test under Mask (high high)
tmhl=Test under Mask (high low)
tml=Test under Mask Low
tmlh=Test under Mask (low high)
tmll=Test under Mask (low low)
tmy=Test under Mask
tp=Test Decimal
tpi=Test Pending Interruption
tprot=Test Protection
tr=Translate
trace=Trace (32)
tracg=Trace (64)
trap2=Trap
trap4=Trap
tre=Translate Extended
troo=Translate One to One
trot=Translate One to Two
trt=Translate and Test
trte=Translate and Test Extended
trto=Translate Two to One
trtr=Translate and Test Reverse
trtre=Translate and Test Reverse Extended
trtt=Translate Two to Two
ts=Test and Set
tsch=Test Subchannel
unpk=Unpack
unpka=Unpack ASCII
unpku=Unpack Unicode
upt=Update Tree
va=Vector Add
vac=Vector Add With Carry
vacc=Vector Add Compute Carry
vaccc=Vector Add With Carry Compute Carry
vavg=Vector Average
vavgl=Vector Average Logical
vcdg=Vector FP Convert from Fixed 64-bit
vcdlg=Vector FP Convert from Logical 64-bit
vceq=Vector Compare Equal
vcgd=Vector FP Convert to Fixed 64-bit
vch=Vector Compare High
vchl=Vector Compare High Logical
vcksm=Vector Checksum
vclgd=Vector FP Convert to Logical 64-bit
vclz=Vector Count Leading Zeros
vctz=Vector Count Trailing Zeros
vec=Vector Element Compare
vecl=Vector Element Compare Logical
verim=Vector Element Rotate and Insert Under
verll=Vector Element Rotate Left Logical
verllv=Vector Element Rotate Left Logical
vesl=Vector Element Shift Left
veslv=Vector Element Shift Left
vesra=Vector Element Shift Right Arithmetic
vesrav=Vector Element Shift Right Arithmetic
vesrl=Vector Element Shift Right Logical
vesrlv=Vector Element Shift Right Logical
vfa=Vector FP Add
vfae=Vector Find Any Element Equal
vfce=Vector FP Compare Equal
vfch=Vector FP Compare High
vfche=Vector FP Compare High or Equal
vfd=Vector FP Divide
vfee=Vector Find Element Equal
vfene=Vector Find Element Not Equal
vfi=Vector Load FP Integer
vfm=Vector FP Multiply
vfma=Vector FP Multiply and Add
vfms=Vector FP Multiply and Subtract
vfpso=Vector FP Perform Sign Operation
vfs=Vector FP Subtract
vfsq=Vector FP Square Root
vftci=Vector FP Test Data Class Immediate
vgbm=Vector Generate Byte Mask
vgef=Vector Gather Element (32)
vgeg=Vector Gather Element (64)
vgfm=Vector Galois Field Multiply Sum
vgfma=Vector Galois Field Multiply Sum and
vgm=Vector Generate Mask
vistr=Vector Isolate String
vl=Vector Load
vlbb=Vector Load to Block Boundary
vlc=Vector Load Complement
vlde=Vector FP Load Lengthened
vleb=Vector Load Element (8)
vled=Vector FP Load Rounded
vlef=Vector Load Element (32)
vleg=Vector Load Element (64)
vleh=Vector Load Element (16)
vleib=Vector Load Element Immediate (8)
vleif=Vector Load Element Immediate (32)
vleig=Vector Load Element Immediate (64)
vleih=Vector Load Element Immediate (16)
vlgv=Vector Load GR from VR Element
vll=Vector Load With Length
vllez=Vector Load Logical Element and Zero
vlm=Vector Load Multiple
vlp=Vector Load Positive
vlr=Vector Load
vlrep=Vector Load and Replicate
vlvg=Vector Load VR Element from GR
vlvgp=Vector Load VR from GRs Disjoint
vmae=Vector Multiply and Add Even
vmah=Vector Multiply and Add High
vmal=Vector Multiply and Add Low
vmale=Vector Multiply and Add Logical Even
vmalh=Vector Multiply and Add Logical High
vmalo=Vector Multiply and Add Logical Odd
vmao=Vector Multiply and Add Odd
vme=Vector Multiply Even
vmh=Vector Multiply High
vml=Vector Multiply Low
vmle=Vector Multiply Logical Even
vmlh=Vector Multiply Logical High
vmlo=Vector Multiply Logical Odd
vmn=Vector Minimum
vmnl=Vector Minimum Logical
vmo=Vector Multiply Odd
vmrh=Vector Merge High
vmrl=Vector Merge Low
vmx=Vector Maximum
vmxl=Vector Maximum Logical
vn=Vector AND
vnc=Vector AND with Complement
vno=Vector NOR
vo=Vector OR
vpdi=Vector Permute Doubleword Immediate
vperm=Vector Permute
vpk=Vector Pack
vpkls=Vector Pack Logical Saturate
vpks=Vector Pack Saturate
vpopct=Vector Population Count
vrep=Vector Replicate
vrepi=Vector Replicate Immediate
vs=Vector Subtract
vsbcbi=Vector Subtract With Borrow Compute
vsbi=Vector Subtract With Borrow Indication
vscbi=Vector Subtract Compute Borrow Indication
vscef=Vector Scatter Element (32)
vsceg=Vector Scatter Element (64)
vseg=Vector Sign Extend to Doubleword
vsel=Vector Select
vsl=Vector Shift Left
vslb=Vector Shift Left By Byte
vsldb=Vector Shift Left Double By Byte
vsra=Vector Shift Right Arithmetic
vsrab=Vector Shift Right Arithmetic By Byte
vsrl=Vector Shift Right Logical
vsrlb=Vector Shift Right Logical By Byte
vst=Vector Store
vsteb=Vector Store Element (8)
vstef=Vector Store Element (32)
vsteg=Vector Store Element (64)
vsteh=Vector Store Element (16)
vstl=Vector Store With Length
vstm=Vector Store Multiple
vstrc=Vector String Range Compare
vsum=Vector Sum Across Word
vsumg=Vector Sum Across Doubleword
vsumq=Vector Sum Across Quadword
vtm=Vector Test Under Mask
vuph=Vector Unpack High
vupl=Vector Unpack Low
vuplh=Vector Unpack Logical High
vupll=Vector Unpack Logical Low
vx=Vector Exclusive OR
wfc=Vector FP Compare Scalar
wfk=Vector FP Compare and Signal Scalar
x=Exclusive OR (32)
xc=Exclusive OR (character)
xg=Exclusive OR (64)
xgr=Exclusive OR (64)
xgrk=Exclusive OR (64)
xi=Exclusive OR Immediate
xihf=Exclusive OR Immediate (high)
xilf=Exclusive OR Immediate (low)
xiy=Exclusive OR Immediate
xr=Exclusive OR (32)
xrk=Exclusive OR (32)
xsch=Cancel Subchannel
xy=Exclusive Or (32)
zap=Zero and Add
