/* This file is in the public domain. */

#define DBG_FLOAT

#include <stdlib.h>

#ifdef DBG_FLOAT
#include <stdio.h>
#endif

#include <math.h>
#include <strings.h>

#include "sortsearch.h"
#include "fnprintf.h"
#include "machine.h"

typedef struct instr INSTR;

struct instr {
  int opcode;
  const char *name;
  int nargs;
  int arginfo[6];
#define AI_SIZE 0xff
#define AI_FLAGS (~0xff)
#define AI_BRANCH  0x100
#define AI_FLOAT   0xe00
#define AI_FLOAT_F 0x200
#define AI_FLOAT_D 0x400
#define AI_FLOAT_G 0x600
#define AI_FLOAT_H 0x800
  } ;

#define CF_EPNT   (CF_MSPEC+0)
#define CF_CASE   (CF_MSPEC+1)
#define CF_FFLOAT (CF_MSPEC+2)
#define CF_DFLOAT (CF_MSPEC+3)
#define CF_GFLOAT (CF_MSPEC+4)
#define CF_HFLOAT (CF_MSPEC+5)

#define BRANCH(n) (AI_BRANCH|(n))
#define FLOAT(kind,n) (AI_FLOAT_##kind|(n))
static INSTR Instrs[]
 = { { 0x0057, "<reserved>", 0 },
     { 0x005a, "<reserved>", 0 },
     { 0x005b, "<reserved>", 0 },
     { 0x0077, "<reserved>", 0 },
     { 0x0059, "???", 0 },
     { 0x009d, "acbb", 4, { 1, 1, 1, BRANCH(2) } },
     { 0x006f, "acbd", 4, { FLOAT(D,8), FLOAT(D,8), FLOAT(D,8), BRANCH(2) } },
     { 0x004f, "acbf", 4, { FLOAT(F,4), FLOAT(F,4), FLOAT(F,4), BRANCH(2) } },
     { 0x4ffd, "acbg", 4, { FLOAT(G,8), FLOAT(G,8), FLOAT(G,8), BRANCH(2) } },
     { 0x6ffd, "acbh", 4, { FLOAT(H,16), FLOAT(H,16), FLOAT(H,16), BRANCH(2) } },
     { 0x00f1, "acbl", 4, { 4, 4, 4, BRANCH(2) } },
     { 0x003d, "acbw", 4, { 2, 2, 2, BRANCH(2) } },
     { 0x0058, "adawi", 2, { 2, 2 } },
     { 0x0080, "addb2", 2, { 1, 1 } },
     { 0x0081, "addb3", 3, { 1, 1, 1 } },
     { 0x0060, "addd2", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0061, "addd3", 3, { FLOAT(D,8), FLOAT(D,8), FLOAT(D,8) } },
     { 0x0040, "addf2", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x0041, "addf3", 3, { FLOAT(F,4), FLOAT(F,4), FLOAT(F,4) } },
     { 0x40fd, "addg2", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x41fd, "addg3", 3, { FLOAT(G,8), FLOAT(G,8), FLOAT(G,8) } },
     { 0x60fd, "addh2", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x61fd, "addh3", 3, { FLOAT(H,16), FLOAT(H,16), FLOAT(H,16) } },
     { 0x00c0, "addl2", 2, { 4, 4 } },
     { 0x00c1, "addl3", 3, { 4, 4, 4 } },
     { 0x0020, "addp4", 4, { 2, 1, 2, 1 } },
     { 0x0021, "addp6", 6, { 2, 1, 2, 1, 2, 1 } },
     { 0x00a0, "addw2", 2, { 2, 2 } },
     { 0x00a1, "addw3", 3, { 2, 2, 2 } },
     { 0x00d8, "adwc", 2, { 4, 4 } },
     { 0x00f3, "aobleq", 3, { 4, 4, BRANCH(1) } },
     { 0x00f2, "aoblss", 3, { 4, 4, BRANCH(1) } },
     { 0x0078, "ashl", 3, { 1, 4, 4 } },
     { 0x00f8, "ashp", 6, { 1, 2, 1, 1, 2, 1 } },
     { 0x0079, "ashq", 3, { 1, 8, 8 } },
     { 0x00e1, "bbc", 3, { 4, 1, BRANCH(1) } },
     { 0x00e5, "bbcc", 3, { 4, 1, BRANCH(1) } },
     { 0x00e7, "bbcci", 3, { 4, 1, BRANCH(1) } },
     { 0x00e3, "bbcs", 3, { 4, 1, BRANCH(1) } },
     { 0x00e0, "bbs", 3, { 4, 1, BRANCH(1) } },
     { 0x00e4, "bbsc", 3, { 4, 1, BRANCH(1) } },
     { 0x00e2, "bbss", 3, { 4, 1, BRANCH(1) } },
     { 0x00e6, "bbssi", 3, { 4, 1, BRANCH(1) } },
     { 0x001e, "bcc", 1, { BRANCH(1) } }, /* bgequ */
     { 0x001f, "bcs", 1, { BRANCH(1) } }, /* blssu */
     { 0x0013, "beql", 1, { BRANCH(1) } },
     { 0x0018, "bgeq", 1, { BRANCH(1) } },
     { 0x0014, "bgtr", 1, { BRANCH(1) } },
     { 0x001a, "bgtru", 1, { BRANCH(1) } },
     { 0x008a, "bicb2", 2, { 1, 1 } },
     { 0x008b, "bicb3", 3, { 1, 1, 1 } },
     { 0x00ca, "bicl2", 2, { 4, 4 } },
     { 0x00cb, "bicl3", 3, { 4, 4, 4 } },
     { 0x00b9, "bicpsw", 1, { 2 } },
     { 0x00aa, "bicw2", 2, { 2, 2 } },
     { 0x00ab, "bicw3", 3, { 2, 2, 2 } },
     { 0x0088, "bisb2", 2, { 1, 1 } },
     { 0x0089, "bisb3", 3, { 1, 1, 1 } },
     { 0x00c8, "bisl2", 2, { 4, 4 } },
     { 0x00c9, "bisl3", 3, { 4, 4, 4 } },
     { 0x00b8, "bispsw", 1, { 2 } },
     { 0x00a8, "bisw2", 2, { 2, 2 } },
     { 0x00a9, "bisw3", 3, { 2, 2, 2 } },
     { 0x0093, "bitb", 2, { 1, 1 } },
     { 0x00d3, "bitl", 2, { 4, 4 } },
     { 0x00b3, "bitw", 2, { 2, 2 } },
     { 0x00e9, "blbc", 2, { 4, BRANCH(1) } },
     { 0x00e8, "blbs", 2, { 4, BRANCH(1) } },
     { 0x0015, "bleq", 1, { BRANCH(1) } },
     { 0x001b, "blequ", 1, { BRANCH(1) } },
     { 0x0019, "blss", 1, { BRANCH(1) } },
     { 0x0012, "bneq", 1, { BRANCH(1) } },
     { 0x0003, "bpt", 0 },
     { 0x0011, "brb", 1, { BRANCH(1) } },
     { 0x0031, "brw", 1, { BRANCH(2) } },
     { 0x0010, "bsbb", 1, { BRANCH(1) } },
     { 0x0030, "bsbw", 1, { BRANCH(2) } },
     { 0x001c, "bvc", 1, { BRANCH(1) } },
     { 0x001d, "bvs", 1, { BRANCH(1) } },
     { 0x00fa, "callg", 2, { 1, 1 } },
     { 0x00fb, "calls", 2, { 4, 1 } },
     { 0x008f, "caseb", 3, { 1, 1, 1 } },
     { 0x00cf, "casel", 3, { 4, 4, 4 } },
     { 0x00af, "casew", 3, { 2, 2, 2 } },
     { 0x00bd, "chme", 1, { 2 } },
     { 0x00bc, "chmk", 1, { 2 } },
     { 0x00be, "chms", 1, { 2 } },
     { 0x00bf, "chmu", 1, { 2 } },
     { 0x0094, "clrb", 1, { 1 } },
     { 0x00d4, "clrl", 1, { 4 } },
     { 0x7cfd, "clro", 1, { 16 } },
     { 0x007c, "clrq", 1, { 8 } },
     { 0x00b4, "clrw", 1, { 2 } },
     { 0x0091, "cmpb", 2, { 1, 1 } },
     { 0x0029, "cmpc3", 3, { 2, 1, 1 } },
     { 0x002d, "cmpc5", 5, { 2, 1, 1, 2, 1 } },
     { 0x0071, "cmpd", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0051, "cmpf", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x51fd, "cmpg", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x71fd, "cmph", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x00d1, "cmpl", 2, { 4, 4 } },
     { 0x0035, "cmpp3", 3, { 2, 1, 1 } },
     { 0x0037, "cmpp4", 4, { 2, 1, 2, 1 } },
     { 0x00ec, "cmpv", 4, { 4, 1, 1, 4 } },
     { 0x00b1, "cmpw", 2, { 2, 2 } },
     { 0x00ed, "cmpzv", 4, { 4, 1, 1, 4 } },
     { 0x000b, "crc", 4, { 1, 4, 2, 1 } },
     { 0x006c, "cvtbd", 2, { 1, FLOAT(D,8) } },
     { 0x004c, "cvtbf", 2, { 1, FLOAT(F,4) } },
     { 0x4cfd, "cvtbg", 2, { 1, FLOAT(G,8) } },
     { 0x6cfd, "cvtbh", 2, { 1, FLOAT(H,16) } },
     { 0x0098, "cvtbl", 2, { 1, 4 } },
     { 0x0099, "cvtbw", 2, { 1, 2 } },
     { 0x0068, "cvtdb", 2, { FLOAT(D,8), 1 } },
     { 0x0076, "cvtdf", 2, { FLOAT(D,8), FLOAT(F,4) } },
     { 0x32fd, "cvtdh", 2, { FLOAT(D,8), FLOAT(H,16) } },
     { 0x006a, "cvtdl", 2, { FLOAT(D,8), 4 } },
     { 0x0069, "cvtdw", 2, { FLOAT(D,8), 2 } },
     { 0x0048, "cvtfb", 2, { FLOAT(F,4), 1 } },
     { 0x0056, "cvtfd", 2, { FLOAT(F,4), FLOAT(D,8) } },
     { 0x99fd, "cvtfg", 2, { FLOAT(F,4), FLOAT(G,8) } },
     { 0x98fd, "cvtfh", 2, { FLOAT(F,4), FLOAT(H,16) } },
     { 0x004a, "cvtfl", 2, { FLOAT(F,4), 4 } },
     { 0x0049, "cvtfw", 2, { FLOAT(F,4), 2 } },
     { 0x48fd, "cvtgb", 2, { FLOAT(G,8), 1 } },
     { 0x33fd, "cvtgf", 2, { FLOAT(G,8), FLOAT(F,4) } },
     { 0x56fd, "cvtgh", 2, { FLOAT(G,8), FLOAT(H,16) } },
     { 0x4afd, "cvtgl", 2, { FLOAT(G,8), 4 } },
     { 0x49fd, "cvtgw", 2, { FLOAT(G,8), 2 } },
     { 0x68fd, "cvthb", 2, { FLOAT(H,16), 1 } },
     { 0xf7fd, "cvthd", 2, { FLOAT(H,16), FLOAT(D,8) } },
     { 0xf6fd, "cvthf", 2, { FLOAT(H,16), FLOAT(F,4) } },
     { 0x76fd, "cvthg", 2, { FLOAT(H,16), FLOAT(G,8) } },
     { 0x6afd, "cvthl", 2, { FLOAT(H,16), 4 } },
     { 0x69fd, "cvthw", 2, { FLOAT(H,16), 2 } },
     { 0x00f6, "cvtlb", 2, { 4, 1 } },
     { 0x006e, "cvtld", 2, { 4, FLOAT(D,8) } },
     { 0x004e, "cvtlf", 2, { 4, FLOAT(F,4) } },
     { 0x4efd, "cvtlg", 2, { 4, FLOAT(G,8) } },
     { 0x6efd, "cvtlh", 2, { 4, FLOAT(H,16) } },
     { 0x00f9, "cvtlp", 3, { 4, 2, 1 } },
     { 0x00f7, "cvtlw", 2, { 4, 2 } },
     { 0x0036, "cvtpl", 3, { 2, 1, 4 } },
     { 0x0008, "cvtps", 4, { 2, 1, 2, 1 } },
     { 0x0024, "cvtpt", 5, { 2, 1, 1, 2, 1 } },
     { 0x006b, "cvtrdl", 2, { FLOAT(D,8), 4 } },
     { 0x004b, "cvtrfl", 2, { FLOAT(F,4), 4 } },
     { 0x4bfd, "cvtrgl", 2, { FLOAT(G,8), 4 } },
     { 0x6bfd, "cvtrhl", 2, { FLOAT(H,16), 4 } },
     { 0x0009, "cvtsp", 4, { 2, 1, 2, 1 } },
     { 0x0026, "cvttp", 5, { 2, 1, 1, 2, 1 } },
     { 0x0033, "cvtwb", 2, { 2, 1 } },
     { 0x006d, "cvtwd", 2, { 2, FLOAT(D,8) } },
     { 0x004d, "cvtwf", 2, { 2, FLOAT(F,4) } },
     { 0x4dfd, "cvtwg", 2, { 2, FLOAT(G,8) } },
     { 0x6dfd, "cvtwh", 2, { 2, FLOAT(H,16) } },
     { 0x0032, "cvtwl", 2, { 2, 4 } },
     { 0x0097, "decb", 1, { 1 } },
     { 0x00d7, "decl", 1, { 4 } },
     { 0x00b7, "decw", 1, { 2 } },
     { 0x0086, "divb2", 2, { 1, 1 } },
     { 0x0087, "divb3", 3, { 1, 1, 1 } },
     { 0x0066, "divd2", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0067, "divd3", 3, { FLOAT(D,8), FLOAT(D,8), FLOAT(D,8) } },
     { 0x0046, "divf2", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x0047, "divf3", 3, { FLOAT(F,4), FLOAT(F,4), FLOAT(F,4) } },
     { 0x46fd, "divg2", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x47fd, "divg3", 3, { FLOAT(G,8), FLOAT(G,8), FLOAT(G,8) } },
     { 0x66fd, "divh2", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x67fd, "divh3", 3, { FLOAT(H,16), FLOAT(H,16), FLOAT(H,16) } },
     { 0x00c6, "divl2", 2, { 4, 4 } },
     { 0x00c7, "divl3", 3, { 4, 4, 4 } },
     { 0x0027, "divp", 6, { 2, 1, 2, 1, 2, 1 } },
     { 0x00a6, "divw2", 2, { 2, 2 } },
     { 0x00a7, "divw3", 3, { 2, 2, 2 } },
     { 0x0038, "editpc", 4, { 2, 1, 1, 1 } },
     { 0x007b, "ediv", 4, { 4, 8, 4, 4 } },
     { 0x0074, "emodd", 5, { FLOAT(D,8), 1, FLOAT(D,8), 4, FLOAT(D,8) } },
     { 0x0054, "emodf", 5, { FLOAT(F,4), 1, FLOAT(F,4), 4, FLOAT(F,4) } },
     { 0x54fd, "emodg", 5, { FLOAT(G,8), 2, FLOAT(G,8), 4, FLOAT(G,8) } },
     { 0x74fd, "emodh", 5, { FLOAT(H,16), 2, FLOAT(H,16), 4, FLOAT(H,16) } },
     { 0x007a, "emul", 4, { 4, 4, 4, 8 } },
     { 0x00ee, "extv", 4, { 4, 1, 1, 4 } },
     { 0x00ef, "extzv", 4, { 4, 1, 1, 4 } },
     { 0x00eb, "ffc", 4, { 4, 1, 1, 4 } },
     { 0x00ea, "ffs", 4, { 4, 1, 1, 4 } },
     { 0x0000, "halt", 0 },
     { 0x0096, "incb", 1, { 1 } },
     { 0x00d6, "incl", 1, { 4 } },
     { 0x00b6, "incw", 1, { 2 } },
     { 0x000a, "index", 6, { 4, 4, 4, 4, 4, 4 } },
     { 0x005c, "insqhi", 2, { 1, 8 } },
     { 0x005d, "insqti", 2, { 1, 8 } },
     { 0x000e, "insque", 2, { 1, 1/*4?8?*/ } },
     { 0x00f0, "insv", 4, { 4, 4, 1, 1 } },
     { 0x0017, "jmp", 1, { 1 } },
     { 0x0016, "jsb", 1, { 1 } },
     { 0x0006, "ldpctx", 0 },
     { 0x003a, "locc", 3, { 1, 2, 1 } },
     { 0x0039, "matchc", 4, { 2, 1, 2, 1 } },
     { 0x0092, "mcomb", 2, { 1, 1 } },
     { 0x00d2, "mcoml", 2, { 4, 4 } },
     { 0x00b2, "mcomw", 2, { 2, 2 } },
     { 0x00db, "mfpr", 2, { 4, 4 } },
     { 0x008e, "mnegb", 2, { 1, 1 } },
     { 0x0072, "mnegd", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0052, "mnegf", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x52fd, "mnegg", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x72fd, "mnegh", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x00ce, "mnegl", 2, { 4, 4 } },
     { 0x00ae, "mnegw", 2, { 2, 2 } },
     { 0x009e, "movab", 2, { 1, 4 } },
     { 0x00de, "moval", 2, { 4, 4 } },
     { 0x7efd, "movao", 2, { 16, 4 } },
     { 0x007e, "movaq", 2, { 8, 4 } },
     { 0x003e, "movaw", 2, { 2, 4 } },
     { 0x0090, "movb", 2, { 1, 1 } },
     { 0x0028, "movc3", 3, { 2, 1, 1 } },
     { 0x002c, "movc5", 5, { 2, 1, 1, 2, 1 } },
     { 0x0070, "movd", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0050, "movf", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x50fd, "movg", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x70fd, "movh", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x00d0, "movl", 2, { 4, 4 } },
     { 0x7dfd, "movo", 2, { 16, 16 } },
     { 0x0034, "movp", 3, { 2, 1, 1 } },
     { 0x00dc, "movpsl", 1, { 4 } },
     { 0x007d, "movq", 2, { 8, 8 } },
     { 0x002e, "movtc", 6, { 2, 1, 1, 1, 2, 1 } },
     { 0x002f, "movtuc", 6, { 2, 1, 1, 1, 2, 1 } },
     { 0x00b0, "movw", 2, { 2, 2 } },
     { 0x009a, "movzbl", 2, { 1, 4 } },
     { 0x009b, "movzbw", 2, { 1, 2 } },
     { 0x003c, "movzwl", 2, { 2, 4 } },
     { 0x00da, "mtpr", 2, { 4, 4 } },
     { 0x0084, "mulb2", 2, { 1, 1 } },
     { 0x0085, "mulb3", 3, { 1, 1, 1 } },
     { 0x0064, "muld2", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0065, "muld3", 3, { FLOAT(D,8), FLOAT(D,8), FLOAT(D,8) } },
     { 0x0044, "mulf2", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x0045, "mulf3", 3, { FLOAT(F,4), FLOAT(F,4), FLOAT(F,4) } },
     { 0x44fd, "mulg2", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x45fd, "mulg3", 3, { FLOAT(G,8), FLOAT(G,8), FLOAT(G,8) } },
     { 0x64fd, "mulh2", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x65fd, "mulh3", 3, { FLOAT(H,16), FLOAT(H,16), FLOAT(H,16) } },
     { 0x00c4, "mull2", 2, { 4, 4 } },
     { 0x00c5, "mull3", 3, { 4, 4, 4 } },
     { 0x0025, "mulp", 6, { 2, 1, 2, 1, 2, 1 } },
     { 0x00a4, "mulw2", 2, { 2, 2 } },
     { 0x00a5, "mulw3", 3, { 2, 2, 2 } },
     { 0x0001, "nop", 0 },
     { 0x0075, "polyd", 3, { FLOAT(D,8), 2, 1 } },
     { 0x0055, "polyf", 3, { FLOAT(F,4), 2, 1 } },
     { 0x55fd, "polyg", 3, { FLOAT(G,8), 2, 1 } },
     { 0x75fd, "polyh", 3, { FLOAT(H,16), 2, 1 } },
     { 0x00ba, "popr", 1, { 2 } },
     { 0x000c, "prober", 3, { 1, 2, 1 } },
     { 0x000d, "probew", 3, { 1, 2, 1 } },
     { 0x009f, "pushab", 1, { 1 } },
     { 0x00df, "pushal", 1, { 4 } },
     { 0x7ffd, "pushao", 1, { 16 } },
     { 0x007f, "pushaq", 1, { 8 } },
     { 0x003f, "pushaw", 1, { 2 } },
     { 0x00dd, "pushl", 1, { 4 } },
     { 0x00bb, "pushr", 1, { 2 } },
     { 0x0002, "rei", 0 },
     { 0x005e, "remqhi", 2, { 8, 4 } },
     { 0x005f, "remqti", 2, { 8, 4 } },
     { 0x000f, "remque", 2, { 1, 4 } },
     { 0x0004, "ret", 0 },
     { 0x009c, "rotl", 3, { 1, 4, 4 } },
     { 0x0005, "rsb", 0 },
     { 0x00d9, "sbwc", 2, { 4, 4 } },
     { 0x002a, "scanc", 4, { 2, 1, 1, 1 } },
     { 0x003b, "skpc", 3, { 1, 2, 1 } },
     { 0x00f4, "sobgeq", 2, { 4, BRANCH(1) } },
     { 0x00f5, "sobgtr", 2, { 4, BRANCH(1) } },
     { 0x002b, "spanc", 4, { 2, 1, 1, 1 } },
     { 0x0082, "subb2", 2, { 1, 1 } },
     { 0x0083, "subb3", 3, { 1, 1, 1 } },
     { 0x0062, "subd2", 2, { FLOAT(D,8), FLOAT(D,8) } },
     { 0x0063, "subd3", 3, { FLOAT(D,8), FLOAT(D,8), FLOAT(D,8) } },
     { 0x0042, "subf2", 2, { FLOAT(F,4), FLOAT(F,4) } },
     { 0x0043, "subf3", 3, { FLOAT(F,4), FLOAT(F,4), FLOAT(F,4) } },
     { 0x42fd, "subg2", 2, { FLOAT(G,8), FLOAT(G,8) } },
     { 0x43fd, "subg3", 3, { FLOAT(G,8), FLOAT(G,8), FLOAT(G,8) } },
     { 0x62fd, "subh2", 2, { FLOAT(H,16), FLOAT(H,16) } },
     { 0x63fd, "subh3", 3, { FLOAT(H,16), FLOAT(H,16), FLOAT(H,16) } },
     { 0x00c2, "subl2", 2, { 4, 4 } },
     { 0x00c3, "subl3", 3, { 4, 4, 4 } },
     { 0x0022, "subp4", 4, { 2, 1, 2, 1 } },
     { 0x0023, "subp6", 6, { 2, 1, 2, 1, 2, 1 } },
     { 0x00a2, "subw2", 2, { 2, 2 } },
     { 0x00a3, "subw3", 3, { 2, 2, 2 } },
     { 0x0007, "svpctx", 0 },
     { 0x0095, "tstb", 1, { 1 } },
     { 0x0073, "tstd", 1, { FLOAT(D,8) } },
     { 0x0053, "tstf", 1, { FLOAT(F,4) } },
     { 0x53fd, "tstg", 1, { FLOAT(G,8) } },
     { 0x73fd, "tsth", 1, { FLOAT(H,16) } },
     { 0x00d5, "tstl", 1, { 4 } },
     { 0x00b5, "tstw", 1, { 2 } },
     { 0x008c, "xorb2", 2, { 1, 1 } },
     { 0x008d, "xorb3", 3, { 1, 1, 1 } },
     { 0x00cc, "xorl2", 2, { 4, 4 } },
     { 0x00cd, "xorl3", 3, { 4, 4, 4 } },
     { 0x00ac, "xorw2", 2, { 2, 2 } },
     { 0x00ad, "xorw3", 3, { 2, 2, 2 } },
     };
#undef BRANCH
#undef FLOAT
#define NINSTRS (sizeof(Instrs)/sizeof(Instrs[0]))
static void *instrs[NINSTRS];
static const char *regname[16] = { "r0", "r1", "r2", "r3",
				   "r4", "r5", "r6", "r7",
				   "r8", "r9", "r10", "r11",
				   "ap", "fp", "sp", "pc" };

static int icmp(void *i1, void *i2)
{
 return(((INSTR *)i2)->opcode-((INSTR *)i1)->opcode);
}

static int dis_oprnd(ADDR addr, void (*fn)(char), int arginfo, CFLAG flg)
{
 ADDR orig;

 orig = addr;
 if (arginfo & AI_BRANCH)
  { int size;
    int off;
    size = arginfo & AI_SIZE;
    if (addr+size > coresize) return(-1);
    off = corefetchs(addr,size);
    addr += size;
    print_symbol_or_hex(fn,corebase+addr+off);
  }
 else
  { int amode;
    int flt;
    flt = arginfo & AI_FLOAT;
    arginfo &= AI_SIZE;
    amode = corefetchu(addr++,1);
    switch (amode & 0xf0)
     { case 0x00: case 0x10: case 0x20: case 0x30: /* short literal */
	  fnprintf(fn,"$%x",amode);
	  if (flt)
	   { switch (amode)
	      { case 000: fnprintf(fn,"=1/2"); break;
		case 001: fnprintf(fn,"=9/16"); break;
		case 002: fnprintf(fn,"=5/8"); break;
		case 003: fnprintf(fn,"=11/16"); break;
		case 004: fnprintf(fn,"=3/4"); break;
		case 005: fnprintf(fn,"=13/16"); break;
		case 006: fnprintf(fn,"=7/8"); break;
		case 007: fnprintf(fn,"=15/16"); break;
		case 010: fnprintf(fn,"=1"); break;
		case 011: fnprintf(fn,"=9/8"); break;
		case 012: fnprintf(fn,"=5/4"); break;
		case 013: fnprintf(fn,"=11/8"); break;
		case 014: fnprintf(fn,"=3/2"); break;
		case 015: fnprintf(fn,"=13/8"); break;
		case 016: fnprintf(fn,"=7/4"); break;
		case 017: fnprintf(fn,"=15/8"); break;
		case 020: fnprintf(fn,"=2"); break;
		case 021: fnprintf(fn,"=9/4"); break;
		case 022: fnprintf(fn,"=5/2"); break;
		case 023: fnprintf(fn,"=11/4"); break;
		case 024: fnprintf(fn,"=3"); break;
		case 025: fnprintf(fn,"=13/4"); break;
		case 026: fnprintf(fn,"=7/2"); break;
		case 027: fnprintf(fn,"=15/4"); break;
		case 030: fnprintf(fn,"=4"); break;
		case 031: fnprintf(fn,"=9/2"); break;
		case 032: fnprintf(fn,"=5"); break;
		case 033: fnprintf(fn,"=11/2"); break;
		case 034: fnprintf(fn,"=6"); break;
		case 035: fnprintf(fn,"=13/2"); break;
		case 036: fnprintf(fn,"=7"); break;
		case 037: fnprintf(fn,"=15/2"); break;
		case 040: fnprintf(fn,"=8"); break;
		case 041: fnprintf(fn,"=9"); break;
		case 042: fnprintf(fn,"=10"); break;
		case 043: fnprintf(fn,"=11"); break;
		case 044: fnprintf(fn,"=12"); break;
		case 045: fnprintf(fn,"=13"); break;
		case 046: fnprintf(fn,"=14"); break;
		case 047: fnprintf(fn,"=15"); break;
		case 050: fnprintf(fn,"=16"); break;
		case 051: fnprintf(fn,"=18"); break;
		case 052: fnprintf(fn,"=20"); break;
		case 053: fnprintf(fn,"=22"); break;
		case 054: fnprintf(fn,"=24"); break;
		case 055: fnprintf(fn,"=26"); break;
		case 056: fnprintf(fn,"=28"); break;
		case 057: fnprintf(fn,"=30"); break;
		case 060: fnprintf(fn,"=32"); break;
		case 061: fnprintf(fn,"=36"); break;
		case 062: fnprintf(fn,"=40"); break;
		case 063: fnprintf(fn,"=44"); break;
		case 064: fnprintf(fn,"=48"); break;
		case 065: fnprintf(fn,"=52"); break;
		case 066: fnprintf(fn,"=56"); break;
		case 067: fnprintf(fn,"=60"); break;
		case 070: fnprintf(fn,"=64"); break;
		case 071: fnprintf(fn,"=72"); break;
		case 072: fnprintf(fn,"=80"); break;
		case 073: fnprintf(fn,"=88"); break;
		case 074: fnprintf(fn,"=96"); break;
		case 075: fnprintf(fn,"=104"); break;
		case 076: fnprintf(fn,"=112"); break;
		case 077: fnprintf(fn,"=120"); break;
		default: abort(); break;
	      }
	   }
	  else
	   { if (flg & CFF_INST_PTRLITS) maybe_print_ptrlit(fn,amode);
	   }
	  break;
       case 0x40: /* ...[rX] */
	  if (addr < coresize)
	   { int inc;
	     inc = dis_oprnd(addr,fn,arginfo,flg);
	     if (inc < 0) return(-1);
	     addr += inc;
	     fnprintf(fn,"[%s]",regname[amode&0xf]);
	   }
	  break;
       case 0x50: /* rX */
	  fnprintf(fn,"%s",regname[amode&0xf]);
	  break;
       case 0x60: /* (rX) */
	  fnprintf(fn,"(%s)",regname[amode&0xf]);
	  break;
       case 0x70: /* -(rX) */
	  fnprintf(fn,"-(%s)",regname[amode&0xf]);
	  break;
       case 0x90: /* *(rX)+ or *$X */
	   { int size;
	     size = 4;
	     fnprintf(fn,"*");
	     if (0)
	      {
       case 0x80: /* (rX)+, or $X */
		size = arginfo & AI_SIZE;
	      }
	     if ((amode&0x0f) == 0x0f) /* $X or *$X */
	      { if (addr+size > coresize) return(-1);
		switch (size)
		 { /* corefetchu() works only up to 32-bit data */
		   case 1:
		   case 2:
		   case 4:
		      fnprintf(fn,"$%0*lx",size*2,corefetchu(addr,size));
		      break;
		   case 8:
		      fnprintf(fn,"$%08lx%08lx",corefetchu(addr,4),corefetchu(addr+4,4));
		      break;
		   case 16:
		      fnprintf(fn,"$%08lx%08lx%08lx%08lx",
				corefetchu(addr,4), corefetchu(addr+4,4),
				corefetchu(addr+8,4), corefetchu(addr+12,4) );
		      break;
		   default:
		      abort();
		      break;
		 }
		if ((size <= 4) && (flg & CFF_INST_PTRLITS)) maybe_print_ptrlit(fn,corefetchu(addr,size));
		addr += size;
	      }
	     else /* (rX)+ or *(rX)+ */
	      { fnprintf(fn,"(%s)+",regname[amode&0xf]);
	      }
	   }
	  break;
       case 0xa0: /* N(rX), N byte; or X */
       case 0xb0: /* *N(rX), N byte; or *X */
       case 0xc0: /* N(rX), N word; or X */
       case 0xd0: /* *N(rX), N word; or *X */
       case 0xe0: /* N(rX), N long; or X */
       case 0xf0: /* *N(rX), N long; or *X */
	   { int size;
	     long int off;
	     switch (amode & 0x60)
	      { case 0x20: /* byte */ size = 1; break;
		case 0x40: /* word */ size = 2; break;
		case 0x60: /* long */ size = 4; break;
	      }
	     if (addr+size > coresize) return(-1);
	     off = corefetchs(addr,size);
	     addr += size;
	     if (amode & 0x10) fnprintf(fn,"*");
	     if ((amode&0x0f) == 0x0f) /* pc-relative: X or *X */
	      { print_symbol_or_hex(fn,corebase+addr+off);
	      }
	     else
	      { if (off < 0)
		 { off = - off;
		   fnprintf(fn,"-");
		 }
		fnprintf(fn,"%0*lx(%s)",2*size,(unsigned long int)off,regname[amode&0xf]);
	      }
	   }
	  break;
     }
  }
 return(addr-orig);
}

static int do_dis_inst(ADDR addr, void (*fn)(char), CFLAG flg)
{
 ADDR orig;
 int iidx;
 INSTR ins;
 INSTR *ip;
 int i;
 int inc;
 ADDR oprnd_a[6];
 int n;
 unsigned long int oprnd;

 addr -= corebase;
 orig = addr;
 ins.opcode = corefetchu(addr,1);
 if ((0xfc&ins.opcode) == 0xfc)
  { if (addr+1 >= coresize) return(-1);
    ins.opcode = corefetchu(addr,2);
    addr += 2;
  }
 else
  { addr ++;
  }
 iidx = bin_search(&instrs[0],NINSTRS,icmp,&ins);
 if (iidx < 0)
  { fnprintf(fn,"<unrecognized ");
    if ((ins.opcode > 0xff) || ((ins.opcode&0xfc) == 0xfc))
     { fnprintf(fn,"%02x %02x>",ins.opcode&0xff,(ins.opcode>>8)&0xff);
     }
    else
     { fnprintf(fn,"%02x>",ins.opcode);
     }
  }
 else
  { ip = (INSTR *) instrs[iidx];
    fnprintf(fn,"%-8s",ip->name);
    for (i=0;i<ip->nargs;i++)
     { if (i) fnprintf(fn,",");
       oprnd_a[i] = addr;
       inc = dis_oprnd(addr,fn,ip->arginfo[i],flg);
       if (inc < 0) return(-1);
       addr += inc;
     }
  }
 if (flg & CFF_INST_PARALLEL)
  { fnprintf(fn," {%lx}",(unsigned long int)(corebase+addr));
    addr = orig + 1;
  }
 else
  { n = addr - orig;
    for (i=1;i<n;i++) flags[orig+i] = CF_PREV;
    switch (ins.opcode)
     { case 0x008f: /* caseb */
	  n = 1;
	  if (0)
	   {
       case 0x00cf: /* casel */
	     n = 4;
	   }
	  if (0)
	   {
       case 0x00af: /* casew */
	     n = 2;
	   }
	  oprnd = corefetchu(oprnd_a[2],1);
	  if (((oprnd & 0xc0) == 0) || (oprnd == 0x8f))
	   { if (oprnd == 0x8f) oprnd = corefetchu(oprnd_a[2]+1,n);
	     for (i=0;i<=oprnd;i++) /* XXX should this be i<oprnd maybe? */
	      { if (addr+i+i >= coresize) break;
		if (addr+i+i+1 >= coresize)
		 { flags[addr+i+i] = CF_BYTE;
		   break;
		 }
		flags[addr+i+i] = CF_CASE;
		flags[addr+i+i+1] = CF_PREV;
	      }
	   }
	  break;
     }
  }
 return(addr-orig);
}

static int do_dis_epnt(ADDR addr, void (*fn)(char))
{
 unsigned short int m;
 int i;
 unsigned short int r;

 addr -= corebase;
 if (addr+2 > coresize) return(-1);
 m = corefetchu(addr,2);
 fnprintf(fn,"entry mask:");
 if (m & 0x8000) fnprintf(fn," dv");
 if (m & 0x4000) fnprintf(fn," iv");
 for ((i=11),(r=1<<11);i>=0;i--,r>>=1)
  { if (m & r) fnprintf(fn," %s",regname[i]);
  }
 flags[addr++] = CF_EPNT;
 flags[addr++] = CF_PREV;
 return(2);
}

static int do_dis_case(ADDR addr, void (*fn)(char))
{
 ADDR base;
 ADDR i;
 int off;

 addr -= corebase;
 if (addr+2 > coresize) return(-1);
 base = addr;
 i = addr;
 while (1)
  { if (flags[i] == CF_CASE) base = i;
    if (i < 1) break;
    switch (flags[i])
     { case CF_CASE:
       case CF_PREV:
	  i --;
	  continue;
	  break;
       default:
	  break;
     }
    break;
  }
 off = corefetchu(addr,2);
 fnprintf(fn,"case -> ");
 print_symbol_or_hex(fn,corebase+base+off);
 flags[addr++] = CF_CASE;
 flags[addr++] = CF_PREV;
 return(2);
}

/*
 * H-float, the most precise of the numbers we work with, has 113 bits
 *  of mantissa, or somewhere near 34 digits.  We carry a few extra
 *  digits for the sake of paranoia (and proper rounding).
 */
#ifdef DBG_FLOAT
static int dbg_float = 0;
static FILE *dbgf = 0;
#endif
#define MAXDIGS 40
#define POWBITS 17
static void print_float(void (*fn)(char), int sign, int exp, unsigned char *mant, int mantbits)
{
 typedef unsigned char DIG;
 static int didinit = 0;
 static unsigned int pow2_bit[POWBITS];
 static DIG pow2_digs[POWBITS][MAXDIGS];
 static int pow2_len[POWBITS];
 static int pow2_log[POWBITS];
 static DIG pow5_digs[POWBITS][MAXDIGS];
 static int pow5_len[POWBITS];
 static int pow5_log[POWBITS];
 static DIG mtbl[10][10];
 DIG digs[MAXDIGS+1];
 DIG prod[2*MAXDIGS];
 int log;
 int n;
 int b;
 int i;
 int h;
 int j;

 static int mult(const DIG *d1, int l1, const DIG *d2, int l2, DIG *p)
  { int prod;
    int i;
    int j;
    int l;
    if (!l1 || !l2) return(0);
    if (! mtbl[1][1]) for (i=0;i<10;i++) for (j=0;j<10;j++) mtbl[i][j] = i * j;
    prod = 0;
    if (l1 < l2)
     { const DIG *td;
       int tl;
       td = d1;
       tl = l1;
       d1 = d2;
       l1 = l2;
       d2 = td;
       l2 = tl;
     }
    for (i=0;i<l2;i++)
     { for (j=0;j<=i;j++) prod += mtbl[d1[i-j]][d2[j]];
       p[i] = prod % 10;
       prod /= 10;
     }
    for (;i<l1;i++)
     { for (j=0;j<l2;j++) prod += mtbl[d1[i-j]][d2[j]];
       p[i] = prod % 10;
       prod /= 10;
     }
    l = l1 + l2 - 1;
    for (;i<l;i++)
     { for (j=l2-1;i-j<l1;j--) prod += mtbl[d1[i-j]][d2[j]];
       p[i] = prod % 10;
       prod /= 10;
     }
    while (prod)
     { p[i] = prod % 10;
       prod /= 10;
       i ++;
     }
    return(i);
  }

 static int allzero(const DIG *d, int n)
  { for (;n>0;n--) if (*d++ != 0) return(0);
    return(1);
  }

 if (! didinit)
  { pow2_bit[0] = 1;
    pow2_digs[0][0] = 2;
    pow2_len[0] = 1;
    bzero(&pow5_digs[0][0],MAXDIGS-1);
    pow5_digs[0][MAXDIGS-1] = 5;
    pow5_len[0] = MAXDIGS;
    for (i=1;i<POWBITS;i++)
     { pow2_bit[i] = pow2_bit[i-1] << 1;
       n = mult(&pow2_digs[i-1][0],pow2_len[i-1],&pow2_digs[i-1][0],pow2_len[i-1],&prod[0]);
       if (n > MAXDIGS)
	{ bcopy(&prod[n-MAXDIGS],&pow2_digs[i][0],MAXDIGS);
	  pow2_len[i] = MAXDIGS;
	  pow2_log[i] = (pow2_log[i-1] * 2) + (n - MAXDIGS);
	}
       else
	{ bcopy(&prod[0],&pow2_digs[i][0],n);
	  pow2_len[i] = n;
	  pow2_log[i] = 0;
	}
       n = mult(&pow5_digs[i-1][0],pow5_len[i-1],&pow5_digs[i-1][0],pow5_len[i-1],&prod[0]);
       bcopy(&prod[n-MAXDIGS],&pow5_digs[i][0],MAXDIGS);
       pow5_len[i] = MAXDIGS;
       pow5_log[i] = (pow5_log[i-1] * 2) + ((MAXDIGS*2) - n);
     }
    didinit = 1;
  }
#ifdef DBG_FLOAT
 if (dbg_float && !dbgf)
  { dbgf = fopen("vax-float.dbg","w");
    setlinebuf(dbgf);
  }
 else if (dbgf && !dbg_float)
  { fclose(dbgf);
    dbgf = 0;
  }
 if (dbg_float)
  { fprintf(dbgf,"\n");
    fprintf(dbgf,"sign=%d exp=%d mant=%x",sign,exp,mant[(mantbits-1)>>3]);
    for (i=((mantbits-1)>>3)-1;i>=0;i--) fprintf(dbgf,"%02x",mant[i]);
    fprintf(dbgf,"\n");
  }
#endif
 digs[0] = 0;
 h = 1;
 for (b=mantbits-1;b>=0;b--)
  { int c;
    c = (mant[b>>3] >> (b&7)) & 1;
    for (i=0;i<h;i++)
     { c += 2 * digs[i];
       if (c >= 10)
	{ digs[i] = c - 10;
	  c = 1;
	}
       else
	{ digs[i] = c;
	  c = 0;
	}
     }
    if (c)
     { if (c != 1) abort();
       digs[h] = 1;
       h ++;
     }
  }
 exp -= mantbits;
#ifdef DBG_FLOAT
 if (dbg_float)
  { fprintf(dbgf,"decimal mant ");
    for (i=h-1;i>=0;i--) fprintf(dbgf,"%d",digs[i]);
    fprintf(dbgf," (exp now %d, sigdigs %d)\n",exp,1+(int)ceil(mantbits*.30103));
  }
#endif
 if (sign) fnprintf(fn,"-");
 if (exp >= 0)
  { log = 0;
    for (b=0;(b<POWBITS)&&exp;b++)
     { if (exp & pow2_bit[b])
	{ exp -= pow2_bit[b];
	  n = mult(&pow2_digs[b][0],pow2_len[b],&digs[0],h,&prod[0]);
	  if (n <= MAXDIGS)
	   { bcopy(&prod[0],&digs[0],n);
	     h = n;
	     log += pow2_log[b];
	   }
	  else
	   { bcopy(&prod[n-MAXDIGS],&digs[0],MAXDIGS);
	     h = MAXDIGS;
	     log += pow2_log[b] + n-MAXDIGS;
	   }
	}
     }
    if (exp) abort();
#ifdef DBG_FLOAT
    if (dbg_float)
     { fprintf(dbgf,"after mults ");
       for (i=h-1;i>=0;i--) fprintf(dbgf,"%d",digs[i]);
       fprintf(dbgf," log %d\n",log);
     }
#endif
    if (h+log < 15)
     { for (i=h-1;i>=0;i--) fnprintf(fn,"%d",digs[i]);
       for (i=log;i>0;i--) fnprintf(fn,"0");
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case A [h=%d log=%d]: ",h,log);
	  for (i=h-1;i>=0;i--) fprintf(dbgf,"%d",digs[i]);
	  for (i=log;i>0;i--) fprintf(dbgf,"0");
	  fprintf(dbgf,"\n");
	}
#endif
       return;
     }
    else
     { n = ceil(mantbits*.30103) + 1;
       if (n > h)
	{ n = h;
	}
       else if (n < h)
	{ if (digs[h-n-1] >= 5)
	   { for (i=h-n;(i<=h)&&(digs[i]==9);i++) digs[i] = 0;
	     if (i > h)
	      { digs[i] = 1;
		h = i;
	      }
	     else
	      { digs[i] ++;
	      }
	   }
	}
       while ((n > 1) && (digs[h-n] == 0)) n --;
       fnprintf(fn,"%d.",digs[h-1]);
       for (i=h-2,j=n-1;j>0;i--,j--) fnprintf(fn,"%d",digs[i]);
       fnprintf(fn,"e%+d",log+h-1);
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case B [h=%d log=%d]: ",h,log);
	  fprintf(dbgf,"%d.",digs[h-1]);
	  for (i=h-2,j=n-1;j>0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,"e%+d",log+h-1);
	  fprintf(dbgf,"\n");
	}
#endif
     }
  }
 else if (exp < 0)
  { exp = - exp;
    log = MAXDIGS - h;
    bcopy(&digs[0],&digs[log],h);
    bzero(&digs[0],log);
    for (b=0;(b<POWBITS)&&exp;b++)
     { if (exp & pow2_bit[b])
	{ exp -= pow2_bit[b];
	  n = mult(&pow5_digs[b][0],pow5_len[b],&digs[0],MAXDIGS,&prod[0]);
	  if (n < MAXDIGS) abort();
	  bcopy(&prod[n-MAXDIGS],&digs[0],MAXDIGS);
	  log += pow5_log[b] + ((MAXDIGS*2) - n);
	}
     }
    if (exp) abort();
#ifdef DBG_FLOAT
    if (dbg_float)
     { fprintf(dbgf,"after mults ");
       for (i=MAXDIGS-1;i>=0;i--) fprintf(dbgf,"%d",digs[i]);
       fprintf(dbgf," log %d\n",log);
     }
#endif
    exp = MAXDIGS-1 - log;
    n = ceil(mantbits*.30103) + 1;
    if (digs[MAXDIGS-1-n] >= 5)
     { for (i=MAXDIGS-n;(i<MAXDIGS)&&(digs[i]==9);i++) digs[i] = 0;
       if (i < MAXDIGS)
	{ digs[i] ++;
	}
       else
	{ digs[MAXDIGS-1] = 1;
	  exp ++;
	  bzero(&digs[MAXDIGS-n],n-1);
	}
     }
    /*
     * Cases:
     *	143000 [n=9, exp=5]
     *		exp is >=0, there are significant digits up to the
     *		decimal point, any significant digits after are zero.
     *	132758____ [n=6, exp=8]
     *		exp is >=0 but not too big; there are no significant
     *		digits after the decimal point.
     *	1341.3716 [n=8, exp=3]
     *		exp is >=0 but not too big; there are nonzero
     *		significant digits after the decimal point.
     *	0.123456
     *		exp is <0 but not too small
     *	1.2345e+10
     *		all other cases.
     */
    if ( (exp >= 0) &&
	 (n >= exp+1) &&
	 allzero(&digs[MAXDIGS-n],n-exp-1) )
     { for (i=MAXDIGS-1,j=exp;j>=0;i--,j--) fnprintf(fn,"%d",digs[i]);
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case C [exp=%d n=%d z=%d@%d]: ",exp,n,n-exp-1,MAXDIGS-n);
	  for (i=MAXDIGS-1,j=exp;j>=0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,"\n");
	}
#endif
     }
    else if ((exp >= n) && (exp <= n+4))
     { for (i=MAXDIGS-1,j=n;j>0;i--,j--) fnprintf(fn,"%d",digs[i]);
       for (j=exp-n;j>=0;j--) fnprintf(fn,"0");
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case D [exp=%d n=%d]: ",exp,n);
	  for (i=MAXDIGS-1,j=n;j>0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  for (j=exp-n;j>=0;j--) fprintf(dbgf,"0");
	  fprintf(dbgf,"\n");
	}
#endif
     }
    else if ((exp >= 0) && (n > exp+1))
     { while ((n > exp+1) && (digs[MAXDIGS-n] == 0)) n --;
       if (n <= exp+1) abort(); /* should have been case C */
       for (i=MAXDIGS-1,j=exp;j>=0;i--,j--) fnprintf(fn,"%d",digs[i]);
       fnprintf(fn,".");
       for (j=n-exp-1;j>0;i--,j--) fnprintf(fn,"%d",digs[i]);
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case E [exp=%d n=%d]: ",exp,n);
	  for (i=MAXDIGS-1,j=exp;j>=0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,".");
	  for (j=n-exp-1;j>0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,"\n");
	}
#endif
     }
    else if ((exp < 0) && (exp > -4))
     { fnprintf(fn,"0.");
       for (j=exp+1;j<0;j++) fnprintf(fn,"0");
       while ((n > 0) && (digs[MAXDIGS-n] == 0)) n --;
       for (i=MAXDIGS-1,j=n;j>0;i--,j--) fnprintf(fn,"%d",digs[i]);
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case F [exp=%d]: ",exp);
	  fprintf(dbgf,"0.");
	  for (j=exp+1;j<0;j++) fprintf(dbgf,"0");
	  for (i=MAXDIGS-1,j=n;j>0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,"\n");
	}
#endif
     }
    else
     { while ((n > 1) && (digs[MAXDIGS-n] == 0)) n --;
       fnprintf(fn,"%d.",digs[MAXDIGS-1]);
       for (i=MAXDIGS-2,j=n-1;j>0;i--,j--) fnprintf(fn,"%d",digs[i]);
       fnprintf(fn,"e%+d",exp);
#ifdef DBG_FLOAT
       if (dbg_float)
	{ fprintf(dbgf,"case G: ");
	  fprintf(dbgf,"%d.",digs[MAXDIGS-1]);
	  for (i=MAXDIGS-2,j=n-1;j>0;i--,j--) fprintf(dbgf,"%d",digs[i]);
	  fprintf(dbgf,"e%+d",exp);
	  fprintf(dbgf,"\n");
	}
#endif
     }
  }
}
#undef NDIGS
#undef POWBITS

static int do_dis_ffloat(ADDR addr, void (*fn)(char))
{
 unsigned long int val;
 int sign;
 int exp;
 unsigned char mant[3];

 addr -= corebase;
 if (addr+4 > coresize) return(-1);
 val = corefetchu(addr,4);
 sign = (val >> 15) & 1;
 exp = (val >> 7) & 0xff;
 mant[0] = (val >> 16) & 0xff;
 mant[1] = (val >> 24) & 0xff;
 mant[2] = ((val      ) & 0x7f) | 0x80;
 fnprintf(fn,".float  ");
 if (exp == 0)
  { if (sign)
     { fnprintf(fn,"<reserved operand %08lx>",val);
     }
    else if (mant == 0)
     { fnprintf(fn,"0.0");
     }
    else
     { fnprintf(fn,"0.0 <%08lx>",val);
     }
  }
 else
  { print_float(fn,sign,exp-128,&mant[0],24);
  }
 flags[addr++] = CF_FFLOAT;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 return(4);
}

static int do_dis_dfloat(ADDR addr, void (*fn)(char))
{
 unsigned long int val[2];
 int sign;
 int exp;
 unsigned char mant[7];

 addr -= corebase;
 if (addr+8 > coresize) return(-1);
 val[0] = corefetchu(addr,4);
 val[1] = corefetchu(addr+4,4);
 sign = (val[0] >> 15) & 1;
 exp = (val[0] >> 7) & 0xff;
 mant[0] = (val[1] >> 16) & 0xff;
 mant[1] = (val[1] >> 24) & 0xff;
 mant[2] = (val[1]      ) & 0xff;
 mant[3] = (val[1] >>  8) & 0xff;
 mant[4] = (val[0] >> 16) & 0xff;
 mant[5] = (val[0] >> 24) & 0xff;
 mant[6] = ((val[0]      ) & 0x7f) | 0x80;
 fnprintf(fn,".double ");
 if (exp == 0)
  { if (sign)
     { fnprintf(fn,"<reserved operand %08lx%08lx>",val[1],val[0]);
     }
    else if (mant == 0)
     { fnprintf(fn,"0.0");
     }
    else
     { fnprintf(fn,"0.0 <%08lx%08lx>",val[1],val[0]);
     }
  }
 else
  { print_float(fn,sign,exp-128,&mant[0],56);
  }
 flags[addr++] = CF_DFLOAT;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 return(8);
}

static int do_dis_gfloat(ADDR addr, void (*fn)(char))
{
 unsigned long int val[2];
 int sign;
 int exp;
 unsigned char mant[7];

 addr -= corebase;
 if (addr+8 > coresize) return(-1);
 val[0] = corefetchu(addr,4);
 val[1] = corefetchu(addr+4,4);
 sign = (val[0] >> 15) & 1;
 exp = (val[0] >> 4) & 0x7ff;
 mant[0] = (val[1] >> 16) & 0xff;
 mant[1] = (val[1] >> 24) & 0xff;
 mant[2] = (val[1]      ) & 0xff;
 mant[3] = (val[1] >>  8) & 0xff;
 mant[4] = (val[0] >> 16) & 0xff;
 mant[5] = (val[0] >> 24) & 0xff;
 mant[6] = ((val[0]      ) & 0x0f) | 0x10;
 fnprintf(fn,".gfloat ");
 if (exp == 0)
  { if (sign)
     { fnprintf(fn,"<reserved operand %08lx%08lx>",val[1],val[0]);
     }
    else if (mant == 0)
     { fnprintf(fn,"0.0");
     }
    else
     { fnprintf(fn,"0.0 <%08lx%08lx>",val[1],val[0]);
     }
  }
 else
  { print_float(fn,sign,exp-1024,&mant[0],53);
  }
 flags[addr++] = CF_GFLOAT;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 flags[addr++] = CF_PREV;
 return(8);
}

static int do_dis_hfloat(ADDR addr, void (*fn)(char))
{
 unsigned long int val[4];
 int sign;
 int exp;
 unsigned char mant[15];

 addr -= corebase;
 if (addr+16 > coresize) return(-1);
 val[0] = corefetchu(addr,4);
 val[1] = corefetchu(addr+4,4);
 val[2] = corefetchu(addr+8,4);
 val[3] = corefetchu(addr+12,4);
 sign = (val[0] >> 15) & 1;
 exp = val[0] & 0x7fff;
 mant[ 0] = (val[3] >> 16) & 0xff;
 mant[ 1] = (val[3] >> 24) & 0xff;
 mant[ 2] = (val[3]      ) & 0xff;
 mant[ 3] = (val[3] >>  8) & 0xff;
 mant[ 4] = (val[2] >> 16) & 0xff;
 mant[ 5] = (val[2] >> 24) & 0xff;
 mant[ 6] = (val[2]      ) & 0xff;
 mant[ 7] = (val[2] >>  8) & 0xff;
 mant[ 8] = (val[1] >> 16) & 0xff;
 mant[ 9] = (val[1] >> 24) & 0xff;
 mant[10] = (val[1]      ) & 0xff;
 mant[11] = (val[1] >>  8) & 0xff;
 mant[12] = (val[0] >> 16) & 0xff;
 mant[13] = (val[0] >> 24) & 0xff;
 mant[14] = 1;
 fnprintf(fn,".hfloat ");
 if (exp == 0)
  { if (sign)
     { fnprintf(fn,"<reserved operand %08lx%08lx%08lx%08lx>",val[3],val[2],val[1],val[0]);
     }
    else if (mant == 0)
     { fnprintf(fn,"0.0");
     }
    else
     { fnprintf(fn,"0.0 <%08lx%08lx%08lx%08lx>",val[3],val[2],val[1],val[0]);
     }
  }
 else
  { print_float(fn,sign,exp-16384,&mant[0],113);
  }
 flags[addr++] = CF_HFLOAT;
  { int i;
    for (i=0;i<15;i++) flags[addr++] = CF_PREV;
  }
 return(16);
}

static void d_command(void)
{
 if (changecur_()) return;
 flags[loc.u.on.aoff] = CF_DFLOAT;
}

static void e_command(void)
{
 if (changecur_()) return;
 flags[loc.u.on.aoff] = CF_EPNT;
}

static void f_command(void)
{
 if (changecur_()) return;
 flags[loc.u.on.aoff] = CF_FFLOAT;
}

static void g_command(void)
{
 if (changecur_()) return;
 flags[loc.u.on.aoff] = CF_GFLOAT;
}

static void h_command(void)
{
 if (changecur_()) return;
 flags[loc.u.on.aoff] = CF_HFLOAT;
}

static void vax_init(void)
{
 int i;

 for (i=0;i<NINSTRS;i++) instrs[i] = (char *) &Instrs[i];
 heap_sort(instrs,NINSTRS,icmp);
}

static int vax_cmd(char ch)
{
 switch (ch)
  { case 'd': d_command(); return(1); break;
    case 'e': e_command(); return(1); break;
    case 'f': f_command(); return(1); break;
    case 'g': g_command(); return(1); break;
    case 'h': h_command(); return(1); break;
  }
 return(0);
}

static int vax_dis(ADDR addr, void (*fn)(char))
{
 int rv;

 switch (flags[addr-corebase])
  { default:
       if (ISINST(flags[addr-corebase]))
	{ rv = do_dis_inst(addr,fn,flags[addr-corebase]);
	}
       else
	{ fnprintf(fn,"<bad flag %lu>",(unsigned long int)flags[addr-corebase]);
	  rv = 1;
	}
       break;
    case CF_EPNT:
       rv = do_dis_epnt(addr,fn);
       break;
    case CF_CASE:
       rv = do_dis_case(addr,fn);
       break;
    case CF_FFLOAT:
       rv = do_dis_ffloat(addr,fn);
       break;
    case CF_DFLOAT:
       rv = do_dis_dfloat(addr,fn);
       break;
    case CF_GFLOAT:
       rv = do_dis_gfloat(addr,fn);
       break;
    case CF_HFLOAT:
       rv = do_dis_hfloat(addr,fn);
       break;
  }
 return(rv);
}

static unsigned long int vax_fetch(const void *base, int size)
#define bp(n) ((unsigned long int)(((const unsigned char *)base)[(n)]))
{
 switch (size)
  { case 1:
       return(bp(0));
       break;
    case 2:
       return((bp(1)<<8)|bp(0));
       break;
    case 4:
       return((bp(3)<<24)|(bp(2)<<16)|(bp(1)<<8)|bp(0));
       break;
  }
 abort();
}
#undef bp

#ifdef DBG_FLOAT
static void vax_debug(void)
{
 char *s;

 if (getstr(
	dbg_float ? "Float debugging currently on.  Do you want it on? "
		  : "Float debugging currently off.  Do you want it on? ",
		&s,0) < 0) return;
 switch (*s)
  { case 'y': case 'Y':
       dbg_float = 1;
       break;
    default:
       dbg_float = 0;
       if (dbgf)
	{ fclose(dbgf);
	  dbgf = 0;
	}
       break;
  }
}
#endif

static const char *vax_names[] = { "VAX", "Vax", "vax", 0 };
static const COLONCMD vax_colons[] = {
#ifdef DBG_FLOAT
				       { "debug", &vax_debug },
#endif
				       { 0 } };
MACHINE machine_vax
 = { &vax_names[0],
     4,
     &vax_init,
     &vax_cmd,
     &vax_dis,
     &vax_fetch,
     &vax_colons[0] };