// SDB-CGEN V1.8.0
// gcc -DMAIN=1 s390.c ; ./a.out > s390.h
#include <ctype.h>
#include <stdio.h>
#include <string.h>

struct kv { const char *name; const char *value; };
static struct kv kvs[] = {
  {"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 (6432)"}, 
  {"agfi","Add Immediate (6432)"}, 
  {"agfr","Add (6432)"}, 
  {"aghi","Add Halfword Immediate (6416)"}, 
  {"aghik","Add Immediate (6416)"}, 
  {"agr","Add (64)"}, 
  {"agrk","Add (64)"}, 
  {"agsi","Add Immediate (648)"}, 
  {"ah","Add Halfword (3216)"}, 
  {"ahhhr","Add High (32)"}, 
  {"ahhlr","Add High (32)"}, 
  {"ahi","Add Halfword Immediate (3216)"}, 
  {"ahik","Add Immediate (3216)"}, 
  {"ahy","Add Halfword (3216)"}, 
  {"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 (6432)"}, 
  {"algfi","Add Logical Immediate (6432)"}, 
  {"algfr","Add Logical (6432)"}, 
  {"alghsik","Add Logical with Signed Immediate"}, 
  {"algr","Add Logical (64)"}, 
  {"algrk","Add Logical (64)"}, 
  {"algsi","Add Logical with Signed Immediate (648)"}, 
  {"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 (328)"}, 
  {"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 (328)"}, 
  {"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"}, 
  {"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"}, 
  {"br","Branch on Condition"}, 
  {"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 (LB32)"}, 
  {"cdfbra","Convert from Fixed (LB32)"}, 
  {"cdfr","Convert from Fixed (LH32)"}, 
  {"cdftr","Convert from Fixed (LD32)"}, 
  {"cdgbr","Convert from Fixed (LB64)"}, 
  {"cdgbra","Convert from Fixed (LB64)"}, 
  {"cdgr","Convert from Fixed (LH64)"}, 
  {"cdgtr","Convert from Fixed (LD64)"}, 
  {"cdgtra","Convert from Fixed (LD64)"}, 
  {"cdlfbr","Convert from Logical (LB32)"}, 
  {"cdlftr","Convert from Logical (LD32)"}, 
  {"cdlgbr","Convert from Logical (LB64)"}, 
  {"cdlgtr","Convert from Logical (LD64)"}, 
  {"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 (LD64)"}, 
  {"cdsy","Compare Double and Swap (32)"}, 
  {"cdtr","Compare (LD)"}, 
  {"cdutr","Convert from Unsigned Packed (LD64)"}, 
  {"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 (SB32)"}, 
  {"cefbra","Convert from Fixed (SB32)"}, 
  {"cefr","Convert from Fixed (SH32)"}, 
  {"cegbr","Convert from Fixed (SB64)"}, 
  {"cegbra","Convert from Fixed (SB64)"}, 
  {"cegr","Convert from Fixed (SH64)"}, 
  {"celfbr","Convert from Logical (SB32)"}, 
  {"celgbr","Convert from Logical (SB64)"}, 
  {"cer","Compare (SH)"}, 
  {"cextr","Compare Biased Exponent (ED)"}, 
  {"cfc","Compare and Form Codeword"}, 
  {"cfdbr","Convert to Fixed (32LB)"}, 
  {"cfdbra","Convert to Fixed (32LB)"}, 
  {"cfdr","Convert to Fixed (32LH)"}, 
  {"cfdtr","Convert to Fixed (32LD)"}, 
  {"cfebr","Convert to Fixed (32SB)"}, 
  {"cfebra","Convert to Fixed (32SB)"}, 
  {"cfer","Convert to Fixed (32SH)"}, 
  {"cfi","Compare Immediate (32)"}, 
  {"cfxbr","Convert to Fixed (32EB)"}, 
  {"cfxbra","Convert to Fixed (32EB)"}, 
  {"cfxr","Convert to Fixed (32EH)"}, 
  {"cfxtr","Convert to Fixed (32ED)"}, 
  {"cg","Compare (64)"}, 
  {"cgdbr","Convert to Fixed (64LB)"}, 
  {"cgdbra","Convert to Fixed (64LB)"}, 
  {"cgdr","Convert to Fixed (64LH)"}, 
  {"cgdtr","Convert to Fixed (64LD)"}, 
  {"cgdtra","Convert to Fixed (64LD)"}, 
  {"cgebr","Convert to Fixed (64SB)"}, 
  {"cgebra","Convert to Fixed (64SB)"}, 
  {"cger","Convert to Fixed (64SH)"}, 
  {"cgf","Compare (6432)"}, 
  {"cgfi","Compare Immediate (6432)"}, 
  {"cgfr","Compare (6432)"}, 
  {"cgfrl","Compare Relative Long (6432)"}, 
  {"cgh","Compare Halfword (6416)"}, 
  {"cghi","Compare Halfword Immediate (6416)"}, 
  {"cghrl","Compare Halfword Relative Long (6416)"}, 
  {"cghsi","Compare Halfword Immediate (6416)"}, 
  {"cgib","Compare Immediate and Branch (648)"}, 
  {"cgij","Compare Immediate and Branch Relative"}, 
  {"cgit","Compare Immediate and Trap (6416)"}, 
  {"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 (64EB)"}, 
  {"cgxbra","Convert to Fixed (64EB)"}, 
  {"cgxr","Convert to Fixed (64EH)"}, 
  {"cgxtr","Convert to Fixed (64ED)"}, 
  {"cgxtra","Convert to Fixed (64ED)"}, 
  {"ch","Compare Halfword (3216)"}, 
  {"chf","Compare High (32)"}, 
  {"chhr","Compare High (32)"}, 
  {"chhsi","Compare Halfword Immediate (1616)"}, 
  {"chi","Compare Halfword Immediate (3216)"}, 
  {"chlr","Compare High (32)"}, 
  {"chrl","Compare Halfword Relative Long (3216)"}, 
  {"chsi","Compare Halfword Immediate (3216)"}, 
  {"chy","Compare Halfword (3216)"}, 
  {"cib","Compare Immediate and Branch (328)"}, 
  {"cih","Compare Immediate High (32)"}, 
  {"cij","Compare Immediate and Branch Relative"}, 
  {"cit","Compare Immediate and Trap (3216)"}, 
  {"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 (32LB)"}, 
  {"clfdtr","Convert to Logical (32LD)"}, 
  {"clfebr","Convert to Logical (32SB)"}, 
  {"clfhsi","Compare Logical Immediate (3216)"}, 
  {"clfi","Compare Logical Immediate (32)"}, 
  {"clfit","Compare Logical Immediate and Trap"}, 
  {"clfxbr","Convert to Logical (32EB)"}, 
  {"clfxtr","Convert to Logical (32ED)"}, 
  {"clg","Compare Logical (64)"}, 
  {"clgdbr","Convert to Logical (64LB)"}, 
  {"clgdtr","Convert to Logical (64LD)"}, 
  {"clgebr","Convert to Logical (64SB)"}, 
  {"clgf","Compare Logical (6432)"}, 
  {"clgfi","Compare Logical Immediate (6432)"}, 
  {"clgfr","Compare Logical (6432)"}, 
  {"clgfrl","Compare Logical Relative Long (6432)"}, 
  {"clghrl","Compare Logical Relative Long (6416)"}, 
  {"clghsi","Compare Logical Immediate (6416)"}, 
  {"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 (64EB)"}, 
  {"clgxtr","Convert to Logical (64ED)"}, 
  {"clhf","Compare Logical High (32)"}, 
  {"clhhr","Compare Logical High (32)"}, 
  {"clhhsi","Compare Logical Immediate (1616)"}, 
  {"clhlr","Compare Logical High (32)"}, 
  {"clhrl","Compare Logical Relative Long (3216)"}, 
  {"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 (64LD)"}, 
  {"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 (128ED)"}, 
  {"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 (64LD)"}, 
  {"cuse","Compare until Substring Equal"}, 
  {"cutfu","Convert UTF-8 to Unicode"}, 
  {"cuutf","Convert Unicode to UTF-8"}, 
  {"cuxtr","Convert to Unsigned Packed (128ED)"}, 
  {"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 (EB32)"}, 
  {"cxfbra","Convert from Fixed (EB32)"}, 
  {"cxfr","Convert from Fixed (EH32)"}, 
  {"cxftr","Convert from Fixed (ED32)"}, 
  {"cxgbr","Convert from Fixed (EB64)"}, 
  {"cxgbra","Convert from Fixed (EB64)"}, 
  {"cxgr","Convert from Fixed (EH64)"}, 
  {"cxgtr","Convert from Fixed (ED64)"}, 
  {"cxgtra","Convert from Fixed (ED64)"}, 
  {"cxlfbr","Convert from Logical (EB32)"}, 
  {"cxlftr","Convert from Logical (ED32)"}, 
  {"cxlgbr","Convert from Logical (EB64)"}, 
  {"cxlgtr","Convert from Logical (ED64)"}, 
  {"cxpt","Convert from Packed (To Extended DFP"}, 
  {"cxr","Compare (EH)"}, 
  {"cxstr","Convert from Signed Packed (ED128)"}, 
  {"cxtr","Compare (ED)"}, 
  {"cxutr","Convert from Unsigned Packed (ED128"}, 
  {"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 (3264)"}, 
  {"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 (3264)"}, 
  {"dlg","Divide Logical (64128)"}, 
  {"dlgr","Divide Logical (64128)"}, 
  {"dlr","Divide Logical (3264)"}, 
  {"dp","Divide Decimal"}, 
  {"dr","Divide (3264)"}, 
  {"dsg","Divide Single (64)"}, 
  {"dsgf","Divide Single (6432)"}, 
  {"dsgfr","Divide Single (6432)"}, 
  {"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 (64LD)"}, 
  {"eextr","Extract Biased Exponent (64ED)"}, 
  {"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 (64LD)"}, 
  {"esea","Extract and Set Extended Authority"}, 
  {"esta","Extract Stacked State"}, 
  {"esxtr","Extract Significance (64ED)"}, 
  {"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 (LD64&LD)"}, 
  {"iextr","Insert Biased Exponent (ED64&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 (328)"}, 
  {"lbh","Load Byte High (328)"}, 
  {"lbr","Load Byte (328)"}, 
  {"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 (6432)"}, 
  {"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 (LHSH)"}, 
  {"ldeb","Load Lengthened (LBSB)"}, 
  {"ldebr","Load Lengthened (LBSB)"}, 
  {"lder","Load Lengthened (LHSH)"}, 
  {"ldetr","Load Lengthened (LDSD)"}, 
  {"ldgr","Load FPR from GR (L64)"}, 
  {"ldr","Load (L)"}, 
  {"ldxbr","Load Rounded (LBEB)"}, 
  {"ldxbra","Load Rounded (LBEB)"}, 
  {"ldxr","Load Rounded (LHEH)"}, 
  {"ldxtr","Load Rounded (LDED)"}, 
  {"ldy","Load (L)"}, 
  {"le","Load (S)"}, 
  {"ledbr","Load Rounded (SBLB)"}, 
  {"ledbra","Load Rounded (SBLB)"}, 
  {"ledr","Load Rounded (SHLH)"}, 
  {"ledtr","Load Rounded (SDLD)"}, 
  {"ler","Load (S)"}, 
  {"lexbr","Load Rounded (SBEB)"}, 
  {"lexbra","Load Rounded (SBEB)"}, 
  {"lexr","Load Rounded (SHEH)"}, 
  {"ley","Load (S)"}, 
  {"lfas","Load FPC and Signal"}, 
  {"lfh","Load High (32)"}, 
  {"lfhat","Load and Trap (32H32)"}, 
  {"lfpc","Load FPC"}, 
  {"lg","Load (64)"}, 
  {"lgat","Load and Trap (64)"}, 
  {"lgb","Load Byte (648)"}, 
  {"lgbr","Load Byte (648)"}, 
  {"lgdr","Load GR from FPR (64L)"}, 
  {"lgf","Load (6432)"}, 
  {"lgfi","Load Immediate (6432)"}, 
  {"lgfr","Load (6432)"}, 
  {"lgfrl","Load Relative Long (6432)"}, 
  {"lgh","Load Halfword (6416)"}, 
  {"lghi","Load Halfword Immediate (6416)"}, 
  {"lghr","Load Halfword (6416)"}, 
  {"lghrl","Load Halfword Relative Long (6416)"}, 
  {"lgr","Load (64)"}, 
  {"lgrl","Load Relative Long (64)"}, 
  {"lh","Load Halfword (3216)"}, 
  {"lhh","Load Halfword High (3216)"}, 
  {"lhi","Load Halfword Immediate (3216)"}, 
  {"lhr","Load Halfword (3216)"}, 
  {"lhrl","Load Halfword Relative Long (3216)"}, 
  {"lhy","Load Halfword (3216)"}, 
  {"llc","Load Logical Character (328)"}, 
  {"llch","Load Logical Character High (328)"}, 
  {"llcr","Load Logical Character (328)"}, 
  {"llgc","Load Logical Character (648)"}, 
  {"llgcr","Load Logical Character (648)"}, 
  {"llgf","Load Logical (6432)"}, 
  {"llgfat","Load and Trap (6432)"}, 
  {"llgfr","Load Logical (6432)"}, 
  {"llgfrl","Load Logical Relative Long (6432)"}, 
  {"llgh","Load Logical Halfword (6416)"}, 
  {"llghr","Load Logical Halfword (6416)"}, 
  {"llghrl","Load Logical Halfword Relative Long"}, 
  {"llgt","Load Logical Thirty One Bits (6431)"}, 
  {"llgtat","Load Logical Thirty One Bits and Trap"}, 
  {"llgtr","Load Logical Thirty One Bits (6431)"}, 
  {"llh","Load Logical Halfword (3216)"}, 
  {"llhh","Load Logical Halfword High (3216)"}, 
  {"llhr","Load Logical Halfword (3216)"}, 
  {"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 (6432&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 (6432)"}, 
  {"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 (6432)"}, 
  {"lpgr","Load Positive (64)"}, 
  {"lpq","Load Pair from Quadword (64&64128)"}, 
  {"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 (LHEH)"}, 
  {"lrer","Load Rounded (SHLH)"}, 
  {"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 (6432)"}, 
  {"ltgfr","Load and Test (6432)"}, 
  {"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 (EHLH)"}, 
  {"lxdb","Load Lengthened (EBLB)"}, 
  {"lxdbr","Load Lengthened (EBLB)"}, 
  {"lxdr","Load Lengthened (EHLH)"}, 
  {"lxdtr","Load Lengthened (EDLD)"}, 
  {"lxe","Load Lengthened (EHSH)"}, 
  {"lxeb","Load Lengthened (EBSB)"}, 
  {"lxebr","Load Lengthened (EBSB)"}, 
  {"lxer","Load Lengthened (EHSH)"}, 
  {"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 (6432)"}, 
  {"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 (EHLH)"}, 
  {"mayh","Multiply and Add Unnormalized (EHHLH)"}, 
  {"mayhr","Multiply and Add Unnormalized (EHHLH)"}, 
  {"mayl","Multiply and Add Unnormalized (EHLLH)"}, 
  {"maylr","Multiply and Add Unnormalized (EHLLH)"}, 
  {"mayr","Multiply and Add Unnormalized (EHLH)"}, 
  {"mc","Monitor Call"}, 
  {"md","Multiply (LH)"}, 
  {"mdb","Multiply (LB)"}, 
  {"mdbr","Multiply (LB)"}, 
  {"mde","Multiply (LHSH)"}, 
  {"mdeb","Multiply (LBSB)"}, 
  {"mdebr","Multiply (LBSB)"}, 
  {"mder","Multiply (LHSH)"}, 
  {"mdr","Multiply (LH)"}, 
  {"mdtr","Multiply (LD)"}, 
  {"mdtra","Multiply (LD)"}, 
  {"me","Multiply (LHSH)"}, 
  {"mee","Multiply (SH)"}, 
  {"meeb","Multiply (SB)"}, 
  {"meebr","Multiply (SB)"}, 
  {"meer","Multiply (SH)"}, 
  {"mer","Multiply (LHSH)"}, 
  {"mfy","Multiply (6432)"}, 
  {"mghi","Multiply Halfword Immediate (6416)"}, 
  {"mh","Multiply Halfword (3216)"}, 
  {"mhi","Multiply Halfword Immediate (3216)"}, 
  {"mhy","Multiply Halfword (6416)"}, 
  {"ml","Multiply Logical (6432)"}, 
  {"mlg","Multiply Logical (12864)"}, 
  {"mlgr","Multiply Logical (12864)"}, 
  {"mlr","Multiply Logical (6432)"}, 
  {"mp","Multiply Decimal"}, 
  {"mr","Multiply (6432)"}, 
  {"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 (6432)"}, 
  {"msgfi","Multiply Single Immediate (6432)"}, 
  {"msgfr","Multiply Single (6432)"}, 
  {"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 (6416)"}, 
  {"mvhhi","Move (1616)"}, 
  {"mvhi","Move (3216)"}, 
  {"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 (EHLH)"}, 
  {"mxdb","Multiply (EBLB)"}, 
  {"mxdbr","Multiply (EBLB)"}, 
  {"mxdr","Multiply (EHLH)"}, 
  {"mxr","Multiply (EH)"}, 
  {"mxtr","Multiply (ED)"}, 
  {"mxtra","Multiply (ED)"}, 
  {"my","Multiply Unnormalized (EHLH)"}, 
  {"myh","Multiply Unnormalized (EHHLH)"}, 
  {"myhr","Multiply Unnormalized (EHHLH)"}, 
  {"myl","Multiply Unnormalized (EHLLH)"}, 
  {"mylr","Multiply Unnormalized (EHLLH)"}, 
  {"myr","Multiply Unnormalized (EHLH)"}, 
  {"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 (6432)"}, 
  {"sgfr","Subtract (6432)"}, 
  {"sgr","Subtract (64)"}, 
  {"sgrk","Subtract (64)"}, 
  {"sh","Subtract Halfword (3216)"}, 
  {"shhhr","Subtract High (32)"}, 
  {"shhlr","Subtract High (32)"}, 
  {"shy","Subtract Halfword (3216)"}, 
  {"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 (6432)"}, 
  {"slgfi","Subtract Logical Immediate (6432)"}, 
  {"slgfr","Subtract Logical (6432)"}, 
  {"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,64128)"}, 
  {"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 (LBLH)"}, 
  {"tbedr","Convert HFP to BFP (SBLH)"}, 
  {"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 (LHSB)"}, 
  {"thdr","Convert BFP to HFP (LHLB)"}, 
  {"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"}, 
  {NULL, NULL}
};
// 0x4f8a70
// TODO
typedef int (*GperfForeachCallback)(void *user, const char *k, const char *v);
int gperf_s390_foreach(GperfForeachCallback cb, void *user) {
  int i = 0; while (kvs[i].name) {
  cb (user, kvs[i].name, kvs[i].value);
  i++;}
  return 0;
}
const char *gperf_s390_get(const char *s) {
  int i = 0; while (kvs[i].name) {
  if (!strcmp (s, kvs[i].name)) return kvs[i].value;
  i++;}
  return NULL;
}
#define sdb_hash_c_s390(x,y) gperf_s390_hash(x)
const unsigned int gperf_s390_hash(const char *s) {
  int sum = strlen (s);
  while (*s) { sum += *s; s++; }
  return sum;
}
struct {const char *name;void *get;void *hash;void *foreach;} gperf_s390 = {
  .name = "s390",
  .get = &gperf_s390_get,
  .hash = &gperf_s390_hash,
  .foreach = &gperf_s390_foreach
};

#if MAIN
int main () {
	const char *s = ((char*(*)(char*))gperf_s390.get)("foo");
	printf ("%s\n", s);
}
#endif
