#include <stdio.h>

char *st_copyright[] = {
" *********************************************************************",
" * Copyright 1989 by H. Edward Hall                                  *",
" *                                                                   *",
" * Permission is hereby granted to copy and to give away this        *",
" * software as long as this notice is preserved in its entirety.     *",
" * You may modify the software or use it for any purpose just as     *",
" * long as you preserve this notice and do not sell the software.    *",
" * No warranty of any kind is made for this software.  The holder    *",
" * of this copyright reserves the right to enhance and/or sell       *",
" * this software with no obligation to provide updates or further    *",
" * free copies; if this should happen you may still use this version *",
" * of the software under the terms you received it with.             *",
" *********************************************************************",
									NULL};

/*
 * Kawai K-1 Patch Dumper
 *   by John Bradley  -  bradley@cis.upenn.edu  -  Rev 3/27/89
 *   based on a subset of Mr. Hall's code.
 */



/*
 * offsets that define the data format.  The file is the output of a K1 full
 * memory dump, with some stuff wrapped around it.
 *
 * The data file is organized as such:
 *      <BYTESKIP> bytes  -   header information.  ignored
 *            2816 bytes  -   first bank of singles (32 patches * 88 bytes)
 *     <BYTESKIP1> bytes  -   ignored
 *            2816 bytes  -   second bank of singles (32 patches * 88 bytes)
 *     <BYTESKIP2> bytes  -   ignored
 *            2431 bytes  -   Multi's (32 patch * 76 bytes)
 *
 * you'll probably only have to modify the three constants to make it read
 * K1 dumps in your format.  You MAY have to modify 'loaddump()' as well
 */

#define BYTESKIP  8		/* skip this number of bytes from BOF */
#define BYTESKIP1 9		/* amt to skip between single banks */
#define BYTESKIP2 9		/* amt to skip between single and multi */

typedef unsigned char byte;


/* Patch parameter descriptor structure */
struct param
{
	byte p_flags;          /* special attributes of this field */
	byte p_type;           /* data conversion for this field */
	byte p_byte;           /* byte within patch */
	byte p_bit;            /* starting bit within byte */
	byte p_nbits;          /* number of bits in field */
	byte p_secbyte;        /* secondary byte within patch */
	byte p_secbit;         /* starting bit within byte */
	byte p_secnbits;       /* number of bits in field */
	byte p_row;            /* row on display screen */
	byte p_col;            /* column on display screen */
	int p_bias;            /* minimum value */
	int p_limit;           /* maximum value */
	char **p_names;        /* strings for ENUM type */
};

typedef struct param PARAM;


/* Enumeration strings for SINGLE display */
char *st_src[]  = {"2", "4"};
char *st_poly[] = {"Poly-1", "Poly-2", "Solo  "};
char *st_am12[] = {"off", "1>2", "2>1"};
char *st_am34[] = {"off", "3>4", "4>3"};
char *st_vshp[] = {"TRI", "SAW", "SQR", "RND"};
char *st_vwhl[] = {"DEP", "SPD"};
char *st_mute[] = {" ", "*"};
char *st_trkg[] = {"No ", "Yes"};
char *st_onof[] = {"off", "On "};
char *st_wave[] =
{"  1 Sin 1st   ", "  2 Sin 2nd   ", "  3 Sin 3rd   ", "  4 Sin 4th   ",
 "  5 Sin 5th   ", "  6 Sin 6th   ", "  7 Sin 7th   ", "  8 Sin 8th   ",
 "  9 Sin 9th   ", " 10 Sin 10th  ", " 11 Sin 11th  ", " 12 Sin 12th  ",
 " 13 Sin 16th  ", " 14 Saw 1     ", " 15 Saw 2     ", " 16 Saw 3     ",
 " 17 Saw 4     ", " 18 Saw 5     ", " 19 Saw 6     ", " 20 Saw 7     ",
 " 21 Saw 8     ", " 22 Saw 9     ", " 23 Saw 10    ", " 24 Saw 11    ",
 " 25 Saw 12    ", " 26 Saw 13    ", " 27 Saw 14    ", " 28 Saw 15    ",
 " 29 Saw 16    ", " 30 Saw 17    ", " 31 Saw 18    ", " 32 Saw 19    ",
 " 33 Square 1  ", " 34 Square 2  ", " 35 Square 3  ", " 36 Square 4  ",
 " 37 Square 5  ", " 38 Invrse Saw", " 39 Triangle  ", " 40 Random    ",
 " 41 Frnch Horn", " 42 String 1  ", " 43 String 2  ", " 44 String Pad",
 " 45 Piano 1   ", " 46 El. Grand ", " 47 E. Piano 1", " 48 E. Piano 2",
 " 49 E. Piano 3", " 50 Clavi     ", " 51 Vibe      ", " 52 A. Guitar ",
 " 53 F. Guitar ", " 54 F. Guitar ", " 55 A. Bass   ", " 56 A. Bass   ",
 " 57 Dig Bass 1", " 58 Pick Bass ", " 59 Dig Bass 2", " 60 Round Bass",
 " 61 Fretless 1", " 62 Fretless 2", " 63 Flute     ", " 64 Pan Flute ",
 " 65 Harmonica ", " 66 Glocken   ", " 67 Tine      ", " 68 Harp      ",
 " 69 Marimba   ", " 70 E. Tom    ", " 71 Log Drum  ", " 72 Jazz Org 1",
 " 73 Mello Pad ", " 74 Synth Solo", " 75 Synth 2   ", " 76 Frnch Horn",
 " 77 Frnch Horn", " 78 Brass     ", " 79 Brass     ", " 80 Brass     ",
 " 81 Brass     ", " 82 Trumpet   ", " 83 Trumpet   ", " 84 Violin    ",
 " 85 String    ", " 86 Piano 1   ", " 87 Piano 2   ", " 88 Piano 3   ",
 " 89 Piano 2   ", " 90 Piano 3   ", " 91 Piano 4   ", " 92 Piano 4   ",
 " 93 El. Grand ", " 94 E. Piano 1", " 95 E. Piano 2", " 96 E. Piano 2",
 " 97 Clavi     ", " 98 Harpschord", " 99 Vibe      ", "100 A. Guitar ",
 "101 F. Guitar ", "102 Strat     ", "103 Strat     ", "104 A. Bass   ",
 "105 Pull Bass ", "106 Pull Bass ", "107 Round Bass", "108 Slap Bass ",
 "109 Slap Bass ", "110 Slap Bass ", "111 Fretless  ", "112 Fretless  ",
 "113 Synth Bass", "114 Synth Bass", "115 Harmonica ", "116 Clarinet  ",
 "117 Clarinet  ", "118 Oboe      ", "119 Oboe      ", "120 Shakuhachi",
 "121 Orient Bel", "122 Orient Bel", "123 Bell      ", "124 Koto      ",
 "125 Sitar     ", "126 E. Tom    ", "127 Log Drum  ", "128 Log Drum  ",
 "129 Steel Drum", "130 Steel Drum", "131 Voice 1   ", "132 Voice 2   ",
 "133 Accordion ", "134 Accordion ", "135 Jazz Org 2", "136 Rock Org 1",
 "137 Draw Bar 1", "138 Draw Bar 2", "139 Pipe Org 1", "140 Pipe Org 2",
 "141 Rock Org 2", "142 Synth Solo", "143 Synth Solo", "144 Synth 2   ",
 "145 Synth 2   ", "146 Synth 3   ", "147 Brass     ", "148 Brass     ",
 "149 Orchestra ", "150 Piano 1   ", "151 Piano 4   ", "152 E. Piano 1",
 "153 E. Piano 1", "154 E. Piano 2", "155 E. Piano 3", "156 Clavi     ",
 "157 Harpschord", "158 Harpschord", "159 Vibe      ", "160 Dig Bass 1",
 "161 Dig Bass 2", "162 Dig Bass 2", "163 Pick bass ", "164 Glocken   ",
 "165 Glocken   ", "166 Tine      ", "167 Tine      ", "168 Tine      ",
 "169 Tube Bell ", "170 Tube Bell ", "171 Tube Bell ", "172 Xylophone ",
 "173 Xylophone ", "174 Harp      ", "175 Koto      ", "176 Sitar     ",
 "177 Sitar     ", "178 Kalimbra  ", "179 Kalimbra  ", "180 Kalimbra  ",
 "181 Log Drum  ", "182 Steel Drum", "183 Pipe Org 3", "184 Pipe Org 3",
 "185 Synth 1   ", "186 Synth 2   ", "187 Synth 3   ", "188 Synth 3   ",
 "189 Synth 4   ", "190 Synth 4   ", "191 Clavi     ", "192 Dig Bass 1",
 "193 Dig Bass 1", "194 Pick Bass ", "195 Pick Bass ", "196 Round Bass",
 "197 Round Bass", "198 Harmonica ", "199 Harmonica ", "200 Harp      ",
 "201 Koto      ", "202 Sitar     ", "203 Marimba   ", "204 Synth 1   ",
 "205 Bass Drum ", "206 A. Snare  ", "207 Tite Snare", "208 E. Snare  ",
 "209 Rim       ", "210 A. Tom    ", "211 High Hat  ", "212 Crash     ",
 "213 Ride      ", "214 Strat Guit", "215 Fuzz Mute ", "216 A. Guitar ",
 "217 F. Guitar ", "218 Guit Harmo", "219 Pull Bass ", "220 Bass Harmo",
 "221 Bowd Strng", "222 Strng Attk", "223 String Sus", "224 Pizzicato ",
 "225 Piano     ", "226 El. Grand ", "227 Piano Nois", "228 Trumpet   ",
 "229 Shak Attck", "230 Shak Sustn", "231 PanFl Attk", "232 PanFl Sust",
 "233 Voice     ", "234 White Nois", "235 Strng Loop", "236 Shak Loop ",
 "237 PanFl Loop", "238 Voice Loop", "239 WhtNois Lp", "240 Snare Loop",
 "241 F. Guit Lp", "242 PulBass Lp", "243 OmniLoop 1", "244 OmniLoop 2",
 "245 OmniLoop 3", "246 OmniLoop 4", "247 OmniLoop 5", "248 OmniLoop 6",
 "249 OmniLoop 7", "250 OmniLoop 8", "251 Snare Rev ", "252 Tom Rev   ",
 "253 F. Guit Rv", "254 Hi Hat Alt", "255 Crash Alt ", "256 PnoNois Al"};

char *st_note[] =
{"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};


/* data types */
#define LSTR 1          /* literal string */
#define ENUM 2          /* enumeration */
#define SNUM 3          /* signed number */
#define UNUM 4          /* unsigned number */
#define SPL1 5          /* coarse frequency display */
#define SPL2 6          /* SINGLE name */
#define SPL3 7          /* MIDI note name */
#define PEND 15         /* end-of-parameters sentinel */
#define FNRM 0x00       /* normal flag */
#define FSC4 0x10       /* display only if SRC == 4 */
#define FSGL 0x20       /* SINGLE component of a MULTIPLE */
#define G(x) (FSGL|x)   /* a specific SINGLE component */
#define FRDW 0x40       /* redraw if value changed */


/* SINGLE parameter list */
PARAM params[] =
{       {FNRM, LSTR,   0, 0, 8,  0, 0, 0,  0, 21,   0,  10, NULL},
	{FRDW, ENUM,  11, 2, 1,  0, 0, 0,  0, 39,   0,   1, st_src},
	{FNRM, UNUM,  10, 0, 8,  0, 0, 0,  0, 47,   0, 100, NULL},
	{FNRM, ENUM,  11, 0, 2,  0, 0, 0,  0, 53,   0,   2, st_poly},
	{FNRM, ENUM,  11, 3, 2,  0, 0, 0,  0, 65,   0,   2, st_am12},
	{FNRM, ENUM,  11, 5, 2,  0, 0, 0,  0, 74,   0,   2, st_am34},
	{FNRM, SNUM,  13, 0, 8,  0, 0, 0,  1, 23, -50,  50, NULL},
	{FNRM, UNUM,  16, 0, 8,  0, 0, 0,  1, 35,   0, 100, NULL},
	{FNRM, ENUM,  17, 0, 2,  0, 0, 0,  1, 50,   0,   3, st_vshp},
	{FNRM, SNUM,  14, 0, 8,  0, 0, 0,  1, 63, -50,  50, NULL},
	{FNRM, ENUM,  17, 5, 2,  0, 0, 0,  1, 75,   0,   1, st_vwhl},
	{FNRM, UNUM,  17, 2, 3,  0, 0, 0,  2,  7,   1,   5, NULL},
	{FNRM, SNUM,  18, 0, 8,  0, 0, 0,  2, 23, -50,  50, NULL},
	{FNRM, UNUM,  19, 0, 8,  0, 0, 0,  2, 34,   0, 100, NULL},
	{FNRM, SNUM,  20, 0, 8,  0, 0, 0,  2, 45, -50,  50, NULL},
	{FNRM, SNUM,  21, 0, 8,  0, 0, 0,  2, 54, -50,  50, NULL},
	{FNRM, SNUM,  12, 0, 8,  0, 0, 0,  2, 63, -50,  50, NULL},
	{FNRM, UNUM,  15, 0, 4,  0, 0, 0,  2, 75,   0,  12, NULL},
/*S1*/  {FNRM, ENUM,  22, 0, 1,  0, 0, 0,  4,  3,   0,   1, st_mute},
	{FNRM, ENUM,  31, 0, 7, 35, 0, 1,  4,  9,   0, 255, st_wave},
	{FNRM, ENUM,  35, 1, 1,  0, 0, 0,  4, 25,   0,   1, st_trkg},
	{FNRM, SPL1,  27, 0, 8,  0, 0, 0,  4, 33,   0, 127, NULL},
	{FNRM, SNUM,  23, 0, 8,  0, 0, 0,  4, 39, -50,  50, NULL},
	{FNRM, SNUM,  83, 0, 8,  0, 0, 0,  4, 44, -50,  50, NULL},
	{FNRM, ENUM,  35, 2, 1,  0, 0, 0,  4, 49,   0,   1, st_onof},
	{FNRM, ENUM,  35, 3, 1,  0, 0, 0,  4, 54,   0,   1, st_onof},
/*S2*/  {FNRM, ENUM,  22, 1, 1,  0, 0, 0,  5,  3,   0,   1, st_mute},
	{FNRM, ENUM,  32, 0, 7, 36, 0, 1,  5,  9,   0, 255, st_wave},
	{FNRM, ENUM,  36, 1, 1,  0, 0, 0,  5, 25,   0,   1, st_trkg},
	{FNRM, SPL1,  28, 0, 8,  0, 0, 0,  5, 33,   0, 127, NULL},
	{FNRM, SNUM,  24, 0, 8,  0, 0, 0,  5, 39, -50,  50, NULL},
	{FNRM, SNUM,  84, 0, 8,  0, 0, 0,  5, 44, -50,  50, NULL},
	{FNRM, ENUM,  36, 2, 1,  0, 0, 0,  5, 49,   0,   1, st_onof},
	{FNRM, ENUM,  36, 3, 1,  0, 0, 0,  5, 54,   0,   1, st_onof},
/*S3*/  {FSC4, ENUM,  22, 2, 1,  0, 0, 0,  6,  3,   0,   1, st_mute},
	{FSC4, ENUM,  33, 0, 7, 37, 0, 1,  6,  9,   0, 255, st_wave},
	{FSC4, ENUM,  37, 1, 1,  0, 0, 0,  6, 25,   0,   1, st_trkg},
	{FSC4, SPL1,  29, 0, 8,  0, 0, 0,  6, 33,   0, 127, NULL},
	{FSC4, SNUM,  25, 0, 8,  0, 0, 0,  6, 39, -50,  50, NULL},
	{FSC4, SNUM,  85, 0, 8,  0, 0, 0,  6, 44, -50,  50, NULL},
	{FSC4, ENUM,  37, 2, 1,  0, 0, 0,  6, 49,   0,   1, st_onof},
	{FSC4, ENUM,  37, 3, 1,  0, 0, 0,  6, 54,   0,   1, st_onof},
/*S4*/  {FSC4, ENUM,  22, 3, 1,  0, 0, 0,  7,  3,   0,   1, st_mute},
	{FSC4, ENUM,  34, 0, 7, 38, 0, 1,  7,  9,   0, 255, st_wave},
	{FSC4, ENUM,  38, 1, 1,  0, 0, 0,  7, 25,   0,   1, st_trkg},
	{FSC4, SPL1,  30, 0, 8,  0, 0, 0,  7, 33,   0, 127, NULL},
	{FSC4, SNUM,  26, 0, 8,  0, 0, 0,  7, 39, -50,  50, NULL},
	{FSC4, SNUM,  86, 0, 8,  0, 0, 0,  7, 44, -50,  50, NULL},
	{FSC4, ENUM,  38, 2, 1,  0, 0, 0,  7, 49,   0,   1, st_onof},
	{FSC4, ENUM,  38, 3, 1,  0, 0, 0,  7, 54,   0,   1, st_onof},
/*S1*/  {FNRM, UNUM,  39, 0, 8,  0, 0, 0,  9, 11,   0, 100, NULL},
	{FNRM, UNUM,  43, 0, 8,  0, 0, 0,  9, 15,   0, 100, NULL},
	{FNRM, UNUM,  47, 0, 8,  0, 0, 0,  9, 19,   0, 100, NULL},
	{FNRM, UNUM,  51, 0, 8,  0, 0, 0,  9, 23,   0, 100, NULL},
	{FNRM, UNUM,  55, 0, 8,  0, 0, 0,  9, 27,   0, 100, NULL},
	{FNRM, UNUM,  59, 0, 8,  0, 0, 0,  9, 31,   0, 100, NULL},
	{FNRM, SNUM,  63, 0, 8,  0, 0, 0,  9, 36, -50,  50, NULL},
	{FNRM, UNUM,  35, 4, 3,  0, 0, 0,  9, 43,   1,   8, NULL},
	{FNRM, SNUM,  67, 0, 8,  0, 0, 0,  9, 48, -50,  50, NULL},
	{FNRM, SNUM,  71, 0, 8,  0, 0, 0,  9, 55, -50,  50, NULL},
	{FNRM, SNUM,  75, 0, 8,  0, 0, 0,  9, 62, -50,  50, NULL},
	{FNRM, SNUM,  79, 0, 8,  0, 0, 0,  9, 68, -50,  50, NULL},
/*S2*/  {FNRM, UNUM,  40, 0, 8,  0, 0, 0, 10, 11,   0, 100, NULL},
	{FNRM, UNUM,  44, 0, 8,  0, 0, 0, 10, 15,   0, 100, NULL},
	{FNRM, UNUM,  48, 0, 8,  0, 0, 0, 10, 19,   0, 100, NULL},
	{FNRM, UNUM,  52, 0, 8,  0, 0, 0, 10, 23,   0, 100, NULL},
	{FNRM, UNUM,  56, 0, 8,  0, 0, 0, 10, 27,   0, 100, NULL},
	{FNRM, UNUM,  60, 0, 8,  0, 0, 0, 10, 31,   0, 100, NULL},
	{FNRM, SNUM,  64, 0, 8,  0, 0, 0, 10, 36, -50,  50, NULL},
	{FNRM, UNUM,  36, 4, 3,  0, 0, 0, 10, 43,   1,   8, NULL},
	{FNRM, SNUM,  68, 0, 8,  0, 0, 0, 10, 48, -50,  50, NULL},
	{FNRM, SNUM,  72, 0, 8,  0, 0, 0, 10, 55, -50,  50, NULL},
	{FNRM, SNUM,  76, 0, 8,  0, 0, 0, 10, 62, -50,  50, NULL},
	{FNRM, SNUM,  80, 0, 8,  0, 0, 0, 10, 68, -50,  50, NULL},
/*S3*/  {FSC4, UNUM,  41, 0, 8,  0, 0, 0, 11, 11,   0, 100, NULL},
	{FSC4, UNUM,  45, 0, 8,  0, 0, 0, 11, 15,   0, 100, NULL},
	{FSC4, UNUM,  49, 0, 8,  0, 0, 0, 11, 19,   0, 100, NULL},
	{FSC4, UNUM,  53, 0, 8,  0, 0, 0, 11, 23,   0, 100, NULL},
	{FSC4, UNUM,  57, 0, 8,  0, 0, 0, 11, 27,   0, 100, NULL},
	{FSC4, UNUM,  61, 0, 8,  0, 0, 0, 11, 31,   0, 100, NULL},
	{FSC4, SNUM,  65, 0, 8,  0, 0, 0, 11, 36, -50,  50, NULL},
	{FSC4, UNUM,  37, 4, 3,  0, 0, 0, 11, 43,   1,   8, NULL},
	{FSC4, SNUM,  69, 0, 8,  0, 0, 0, 11, 48, -50,  50, NULL},
	{FSC4, SNUM,  73, 0, 8,  0, 0, 0, 11, 55, -50,  50, NULL},
	{FSC4, SNUM,  77, 0, 8,  0, 0, 0, 11, 62, -50,  50, NULL},
	{FSC4, SNUM,  81, 0, 8,  0, 0, 0, 11, 68, -50,  50, NULL},
/*S4*/  {FSC4, UNUM,  42, 0, 8,  0, 0, 0, 12, 11,   0, 100, NULL},
	{FSC4, UNUM,  46, 0, 8,  0, 0, 0, 12, 15,   0, 100, NULL},
	{FSC4, UNUM,  50, 0, 8,  0, 0, 0, 12, 19,   0, 100, NULL},
	{FSC4, UNUM,  54, 0, 8,  0, 0, 0, 12, 23,   0, 100, NULL},
	{FSC4, UNUM,  58, 0, 8,  0, 0, 0, 12, 27,   0, 100, NULL},
	{FSC4, UNUM,  62, 0, 8,  0, 0, 0, 12, 31,   0, 100, NULL},
	{FSC4, SNUM,  66, 0, 8,  0, 0, 0, 12, 36, -50,  50, NULL},
	{FSC4, UNUM,  38, 4, 3,  0, 0, 0, 12, 43,   1,   8, NULL},
	{FSC4, SNUM,  70, 0, 8,  0, 0, 0, 12, 48, -50,  50, NULL},
	{FSC4, SNUM,  74, 0, 8,  0, 0, 0, 12, 55, -50,  50, NULL},
	{FSC4, SNUM,  78, 0, 8,  0, 0, 0, 12, 62, -50,  50, NULL},
	{FSC4, SNUM,  82, 0, 8,  0, 0, 0, 12, 68, -50,  50, NULL},
	{FNRM, PEND,   0, 0, 0,  0, 0, 0,  0,  0,   0,   0, NULL}};

/* MULTIPLE enumeration strings */
char *st_vlsw[] = {"All ", "Soft", "Loud"};
char *st_mmod[] = {"Kybd", "Midi", "Mix "};
char *st_chan[] = {"R  ", "L+R", "L  "};
char *st_mply[] = {"VR", "0 ", "1 ", "2 ", "3 ", "4 ", "5 ", "6 ", "7 ", "8 "};


/* MULTIPLE parameter list */
PARAM mparams[] = {
	{FNRM, LSTR,   0, 0, 8,  0, 0, 0, 0, 23,   0,  10, NULL},
	{FNRM, UNUM,  10, 0, 8,  0, 0, 0, 0, 43,   1, 100, NULL},
/*S1*/  {G(1), SPL2,  11, 0, 6,  0, 0, 0, 2,  4,   0,  63, NULL},
	{G(1), UNUM,  67, 0, 8,  0, 0, 0, 2, 20,   0, 100, NULL},
	{G(1), SNUM,  51, 0, 6,  0, 0, 0, 2, 25, -24,  24, NULL},
	{G(1), SNUM,  59, 0, 8,  0, 0, 0, 2, 30, -50,  50, NULL},
	{G(1), ENUM,  35, 4, 2,  0, 0, 0, 2, 35,   0,   2, st_chan},
	{FRDW, ENUM,  35, 0, 4,  0, 0, 0, 2, 40,   0,   9, st_mply},
	{G(1), UNUM,  43, 0, 4,  0, 0, 0, 2, 45,   1,  16, NULL},
	{G(1), SPL3,  19, 0, 8,  0, 0, 0, 2, 49,   0, 127, NULL},
	{G(1), SPL3,  27, 0, 8,  0, 0, 0, 2, 54,   0, 127, NULL},
	{G(1), ENUM,  43, 4, 2,  0, 0, 0, 2, 59,   0,   2, st_vlsw},
	{G(1), ENUM,  35, 6, 1, 43, 6, 1, 2, 65,   0,   2, st_mmod},
/*S2*/  {G(2), SPL2,  12, 0, 6,  0, 0, 0, 3,  4,   0,  63, NULL},
	{G(2), UNUM,  68, 0, 8,  0, 0, 0, 3, 20,   0, 100, NULL},
	{G(2), SNUM,  52, 0, 6,  0, 0, 0, 3, 25, -24,  24, NULL},
	{G(2), SNUM,  60, 0, 8,  0, 0, 0, 3, 30, -50,  50, NULL},
	{G(2), ENUM,  36, 4, 2,  0, 0, 0, 3, 35,   0,   2, st_chan},
	{FRDW, ENUM,  36, 0, 4,  0, 0, 0, 3, 40,   0,   9, st_mply},
	{G(2), UNUM,  44, 0, 4,  0, 0, 0, 3, 45,   1,  16, NULL},
	{G(2), SPL3,  20, 0, 8,  0, 0, 0, 3, 49,   0, 127, NULL},
	{G(2), SPL3,  28, 0, 8,  0, 0, 0, 3, 54,   0, 127, NULL},
	{G(2), ENUM,  44, 4, 2,  0, 0, 0, 3, 59,   0,   2, st_vlsw},
	{G(2), ENUM,  36, 6, 1, 44, 6, 1, 3, 65,   0,   2, st_mmod},
/*S3*/  {G(3), SPL2,  13, 0, 6,  0, 0, 0, 4,  4,   0,  63, NULL},
	{G(3), UNUM,  69, 0, 8,  0, 0, 0, 4, 20,   0, 100, NULL},
	{G(3), SNUM,  53, 0, 6,  0, 0, 0, 4, 25, -24,  24, NULL},
	{G(3), SNUM,  61, 0, 8,  0, 0, 0, 4, 30, -50,  50, NULL},
	{G(3), ENUM,  37, 4, 2,  0, 0, 0, 4, 35,   0,   2, st_chan},
	{FRDW, ENUM,  37, 0, 4,  0, 0, 0, 4, 40,   0,   9, st_mply},
	{G(3), UNUM,  45, 0, 4,  0, 0, 0, 4, 45,   1,  16, NULL},
	{G(3), SPL3,  21, 0, 8,  0, 0, 0, 4, 49,   0, 127, NULL},
	{G(3), SPL3,  29, 0, 8,  0, 0, 0, 4, 54,   0, 127, NULL},
	{G(3), ENUM,  45, 4, 2,  0, 0, 0, 4, 59,   0,   2, st_vlsw},
	{G(3), ENUM,  37, 6, 1, 45, 6, 1, 4, 65,   0,   2, st_mmod},
/*S4*/  {G(4), SPL2,  14, 0, 6,  0, 0, 0, 5,  4,   0,  63, NULL},
	{G(4), UNUM,  70, 0, 8,  0, 0, 0, 5, 20,   0, 100, NULL},
	{G(4), SNUM,  54, 0, 6,  0, 0, 0, 5, 25, -24,  24, NULL},
	{G(4), SNUM,  62, 0, 8,  0, 0, 0, 5, 30, -50,  50, NULL},
	{G(4), ENUM,  38, 4, 2,  0, 0, 0, 5, 35,   0,   2, st_chan},
	{FRDW, ENUM,  38, 0, 4,  0, 0, 0, 5, 40,   0,   9, st_mply},
	{G(4), UNUM,  46, 0, 4,  0, 0, 0, 5, 45,   1,  16, NULL},
	{G(4), SPL3,  22, 0, 8,  0, 0, 0, 5, 49,   0, 127, NULL},
	{G(4), SPL3,  30, 0, 8,  0, 0, 0, 5, 54,   0, 127, NULL},
	{G(4), ENUM,  46, 4, 2,  0, 0, 0, 5, 59,   0,   2, st_vlsw},
	{G(4), ENUM,  38, 6, 1, 46, 6, 1, 5, 65,   0,   2, st_mmod},
/*S5*/  {G(5), SPL2,  15, 0, 6,  0, 0, 0, 6,  4,   0,  63, NULL},
	{G(5), UNUM,  71, 0, 8,  0, 0, 0, 6, 20,   0, 100, NULL},
	{G(5), SNUM,  55, 0, 6,  0, 0, 0, 6, 25, -24,  24, NULL},
	{G(5), SNUM,  63, 0, 8,  0, 0, 0, 6, 30, -50,  50, NULL},
	{G(5), ENUM,  39, 4, 2,  0, 0, 0, 6, 35,   0,   2, st_chan},
	{FRDW, ENUM,  39, 0, 4,  0, 0, 0, 6, 40,   0,   9, st_mply},
	{G(5), UNUM,  47, 0, 4,  0, 0, 0, 6, 45,   1,  16, NULL},
	{G(5), SPL3,  23, 0, 8,  0, 0, 0, 6, 49,   0, 127, NULL},
	{G(5), SPL3,  31, 0, 8,  0, 0, 0, 6, 54,   0, 127, NULL},
	{G(5), ENUM,  47, 4, 2,  0, 0, 0, 6, 59,   0,   2, st_vlsw},
	{G(5), ENUM,  39, 6, 1, 47, 6, 1, 6, 65,   0,   2, st_mmod},
/*S6*/  {G(6), SPL2,  16, 0, 6,  0, 0, 0, 7,  4,   0,  63, NULL},
	{G(6), UNUM,  72, 0, 8,  0, 0, 0, 7, 20,   0, 100, NULL},
	{G(6), SNUM,  56, 0, 6,  0, 0, 0, 7, 25, -24,  24, NULL},
	{G(6), SNUM,  64, 0, 8,  0, 0, 0, 7, 30, -50,  50, NULL},
	{G(6), ENUM,  40, 4, 2,  0, 0, 0, 7, 35,   0,   2, st_chan},
	{FRDW, ENUM,  40, 0, 4,  0, 0, 0, 7, 40,   0,   9, st_mply},
	{G(6), UNUM,  48, 0, 4,  0, 0, 0, 7, 45,   1,  16, NULL},
	{G(6), SPL3,  24, 0, 8,  0, 0, 0, 7, 49,   0, 127, NULL},
	{G(6), SPL3,  32, 0, 8,  0, 0, 0, 7, 54,   0, 127, NULL},
	{G(6), ENUM,  48, 4, 2,  0, 0, 0, 7, 59,   0,   2, st_vlsw},
	{G(6), ENUM,  40, 6, 1, 48, 6, 1, 7, 65,   0,   2, st_mmod},
/*S7*/  {G(7), SPL2,  17, 0, 6,  0, 0, 0, 8,  4,   0,  63, NULL},
	{G(7), UNUM,  73, 0, 8,  0, 0, 0, 8, 20,   0, 100, NULL},
	{G(7), SNUM,  57, 0, 6,  0, 0, 0, 8, 25, -24,  24, NULL},
	{G(7), SNUM,  65, 0, 8,  0, 0, 0, 8, 30, -50,  50, NULL},
	{G(7), ENUM,  41, 4, 2,  0, 0, 0, 8, 35,   0,   2, st_chan},
	{FRDW, ENUM,  41, 0, 4,  0, 0, 0, 8, 40,   0,   9, st_mply},
	{G(7), UNUM,  49, 0, 4,  0, 0, 0, 8, 45,   1,  16, NULL},
	{G(7), SPL3,  25, 0, 8,  0, 0, 0, 8, 49,   0, 127, NULL},
	{G(7), SPL3,  33, 0, 8,  0, 0, 0, 8, 54,   0, 127, NULL},
	{G(7), ENUM,  49, 4, 2,  0, 0, 0, 8, 59,   0,   2, st_vlsw},
	{G(7), ENUM,  41, 6, 1, 49, 6, 1, 8, 65,   0,   2, st_mmod},
/*S8*/  {G(8), SPL2,  18, 0, 6,  0, 0, 0, 9,  4,   0,  63, NULL},
	{G(8), UNUM,  74, 0, 8,  0, 0, 0, 9, 20,   0, 100, NULL},
	{G(8), SNUM,  58, 0, 6,  0, 0, 0, 9, 25, -24,  24, NULL},
	{G(8), SNUM,  66, 0, 8,  0, 0, 0, 9, 30, -50,  50, NULL},
	{G(8), ENUM,  42, 4, 2,  0, 0, 0, 9, 35,   0,   2, st_chan},
	{FRDW, ENUM,  42, 0, 4,  0, 0, 0, 9, 40,   0,   9, st_mply},
	{G(8), UNUM,  50, 0, 4,  0, 0, 0, 9, 45,   1,  16, NULL},
	{G(8), SPL3,  26, 0, 8,  0, 0, 0, 9, 49,   0, 127, NULL},
	{G(8), SPL3,  34, 0, 8,  0, 0, 0, 9, 54,   0, 127, NULL},
	{G(8), ENUM,  50, 4, 2,  0, 0, 0, 9, 59,   0,   2, st_vlsw},
	{G(8), ENUM,  42, 6, 1, 50, 6, 1, 9, 65,   0,   2, st_mmod},
	{FNRM, PEND,   0, 0, 0,  0, 0, 0, 0,  0,   0,   0, NULL}
};





/* Templates: */

#define STEMPLINES 13

char *st_singletemp[] = {
"SINGLE Patch     : '          ' | Src   | Vol     |        | AM     | AM",
" KS  | Vibrato: Depth     | Speed     |    Shape         | AT     | Wheel",
"Curve   | Bend: Depth     | Time      | Vel     | KS     | AT     | Range",
"SOURCES:      Wave     Trkng   Coarse Fine f/KS Bend f/AT",
"   S1",
"   S2",
"   S3",
"   S4",
"Envelope: Lev Del Att Dec Sus Rel Lev/V V/Cur Lev/AT Lev/KS Dur/V Dur/KS",
"   S1",
"   S2",
"   S3",
"   S4",
NULL
};


#define MTEMPLINES 10

char *st_multitemp[] = {
"MULTIPLE Patch     : '          '  | Vol",
"      Source       Levl Tran Tune Out Poly Chan ZnLo ZnHi VSwch Mode",
"S1",
"S2",
"S3",
"S4",
"S5",
"S6",
"S7",
"S8",
NULL
};



/* the K1 data */

byte dump[64][88];     /* 64 SINGLE patch array */
byte mdump[32][76];    /* 32 MULTIPLE patch array */

char SCRN[80*24];		/* virtual term screen */






/****************************************************************/
main(argc, argv)
int    argc;
char **argv;
{
  int   a,i,j,dir;
  char *fname;
  
  dir = 0;

  for (i=1; i<argc; i++) {
    if (strcmp(argv[i],"-d")==0) dir++;            /* directory only */

    else if (argv[i][0] == '-') {                  /* invalid option */
      fprintf(stderr, "usage %s: <-d> [filename] <filename ...>\n",argv[0]);
      exit(-1);
    }

    else {                                         /* filename */
      if (loaddump(argv[i])) continue;             /* skip bad files */

      printf("Filename:  %s\n\n\n",argv[i]);
      printf("SINGLES:\n");
      printf("--------\n\n");
      SingleDir();

      printf("\n\n\n");
      printf("MULTIS:\n");
      printf("-------\n\n");
      MultiDir();

      printf("\014\n");

      if (!dir) {
	for (j=0; j<64; j++) {
	  SinglePatch(j);
	  PrintScrn(STEMPLINES);
	  if ((j+1)%4) printf("\n---------------------------\n\n");
	  else printf("\014\n");
	}
     
	for (j=0; j<32; j++) {
	  MultiPatch(j);
	  PrintScrn(MTEMPLINES);
	  if ((j+1)%5) printf("\n---------------------------\n\n");
	  else printf("\014\n");
	}
        printf("\014\n");
      }
    }
  }
}




/****************************************************************/
STcpy(s1,s2)
char *s1, *s2;
{ 
  /* like strcpy, but doesn't copy trailing '\0' */
  for ( ; *s2; s1++,s2++) *s1 = *s2;
}


/****************************************************************/
PrintScrn(n)
int n;
{
  int i,j;
  char *sp;

  for (i=0; i<n; i++) {
    for (j=0; j<79; j++) putchar(SCRN[i*80+j]);
    putchar('\n');
    }
}


/****************************************************************/
ClearScrn()
{
  int i;
  char *sp;

  for (i=0, sp=SCRN; i<80*24; i++,sp++) *sp=' ';
}


/****************************************************************/
SingleTemplate()
{
  int i;

  ClearScrn();
  for (i=0; i<STEMPLINES; i++)
    STcpy(&SCRN[i*80], st_singletemp[i]);
}


/****************************************************************/
MultiTemplate()
{
  int i;

  ClearScrn();
  for (i=0; i<MTEMPLINES; i++)
    STcpy(&SCRN[i*80], st_multitemp[i]);
}



/****************************************************************/
SinglePatch(pnum)
int pnum;
{
  /* prints single patch #pnum to SCRN */

  register PARAM *pp;
  byte *dp;
  char *idstr();

  dp = dump[pnum];
  SingleTemplate();
  for (pp=params; pp->p_type != PEND; pp++)
    if (visible(pp, dp, 1)) showparam(pp,dp);

  STcpy(&SCRN[14],idstr(pnum));
}


/****************************************************************/
MultiPatch(pnum)
int pnum;
{
  /* prints multi patch #pnum to SCRN */

  register PARAM *pp;
  byte *dp;
  char *idstr();

  dp = mdump[pnum];
  MultiTemplate();
  for (pp=mparams; pp->p_type != PEND; pp++) {
       if (visible(pp, dp, 0)) showparam(pp,dp);
  }

  STcpy(&SCRN[16],idstr(pnum));
}



/****************************************************************/
char *idstr(n)
int n;
{
  /* returns a Kawai-style ID for a given patch # */

  static char *st_plet[] = {"IA", "IB", "IC", "ID", "iA", "iB", "iC", "iD"};
  static char tstr[10];

  n &= 0x3f;
  sprintf(tstr, "%s-%d", st_plet[n>>3], 1+(n&0x7));
  return tstr;
}




/****************************************************************/
showparam(pp, dp)
PARAM *pp;
byte  *dp;
{
  int val;

  if (pp->p_type == LSTR) {
    showval(pp, 0, dp);
    return;
  }

  val = getvalue(pp, dp);
  if (val > pp->p_limit) showstr(pp, "#");
                    else showval(pp, val, dp);
}


/****************************************************************/
int getvalue(pp, dp)
PARAM *pp;
byte  *dp;
{
  /* return the value (integer) of a parameter, given a pointer to 
     its descriptor and a pointer to the data */


  static int bitmask[]={0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
  int val;

  val = (dp[pp->p_byte]>>pp->p_bit)&bitmask[pp->p_nbits];
  if (pp->p_secnbits > 0)
    val |= ((dp[pp->p_secbyte]>>pp->p_secbit)
	    &bitmask[pp->p_secnbits])<<pp->p_nbits;
  val += pp->p_bias;
  return val;
}


/****************************************************************/
char *valstr(pp, val, dp)
PARAM *pp;
int    val;
byte  *dp;
{
  /* convert the integer value of a parameter to its display form */

  static char str[40];

  switch (pp->p_type) {
    case LSTR:  strncpy(str, (char *)&dp[pp->p_byte], pp->p_limit);
                str[pp->p_limit] = '\0';
		break;

    case ENUM:  strcpy(str, pp->p_names[val]);
		break;

    case UNUM:  sprintf(str, "%d  ", val);
		if (pp->p_limit > 99)     str[3] = '\0';
		else if (pp->p_limit > 9) str[2] = '\0';
                else                      str[1] = '\0';
		break;

    case SPL1:  if ((dp[pp->p_byte+8]&02) == 0)
                  sprintf(str, "%s%d  ", st_note[val%12], val/12-4);

		else {
		  if (val >= 84) sprintf(str, "+%d  ", val-84);
			    else sprintf(str, "-%d  ", 84-val);
		  }

		str[4] = '\0';
		break;

    case SPL2:  sprintf(str, "%s ", idstr(val));
		strncpy(str+5, (char *)&dump[val][0], 10);
		str[15] = '\0';
		break;

    case SPL3:  sprintf(str, "%s%d  ", st_note[val%12], val/12-2);
		str[4] = '\0';
		break;

    case SNUM:	if (val<0) {
                  str[0] = '-';
		  val = -val;
		  }
		else
		  str[0] = '+';

		sprintf(str+1, "%d  ", val);

		if (pp->p_limit > 99)     str[4] = '\0';
		else if (pp->p_limit > 9) str[3] = '\0';
		else                      str[2] = '\0';
		break;
	}
	return str;
}



/****************************************************************/
showval(pp, val, dp)
PARAM *pp;
int    val;
byte  *dp;
{
  /* given a parameter desc., value, and patch, print param onto SCRN */
  showstr(pp, valstr(pp, val, dp));
}


/****************************************************************/
showstr(pp, str)
PARAM *pp;
char  *str;
{
  /* given a parameter desc. and a string, print string onto SCRN */

  STcpy(&SCRN[(pp->p_row * 80) + (pp->p_col-1)], str);
}



/****************************************************************/
int visible(pp, dp, single)
PARAM *pp;
byte  *dp;
int    single;
{
  /* given a parameter desc. and patch, return true if it's visible */
  int flags;

  flags = pp->p_flags;

  if (single) {
    if ((flags&FSC4) != 0 && (dp[11]&0x4) == 0) return 0;
                                           else return 1;
    }

  else {
    if ((flags&FSGL) != 0 && (dp[34+(flags&0x0f)]&0x0f) == 1) return 0;
                                                         else return 1;
    }
}


/****************************************************************/
int loaddump(file)
char *file;
{
  /* load buffers from named file */

  int   i,j;
  FILE *fp = fopen(file, "r");

  if (fp == NULL) {
    fprintf(stderr,"Can't open file %s", file);
    return(1);
    }

  else {    /* successful open */
    j = 0;
    for (i=0; i<BYTESKIP; i++) getc(fp);

    if (fread((char *)&dump[0][0], 88, 32, fp) != 32) j++;
    for (i=0; i<BYTESKIP1; i++) getc(fp);
    if (fread((char *)&dump[32][0], 88, 32, fp) != 32) j++;
    for (i=0; i<BYTESKIP2; i++) getc(fp);

    if (fread((char *)&mdump[0][0], 76, 32, fp) != 32) j++;
    fclose(fp);
    }

  if (j) {
      fprintf(stderr,"Trouble reading %s", file);
      return(1);
      }

  return(0);
}




/****************************************************************/
SingleDir()
{
  /* prints the directory of Singles (both banks) in this file */

  int i,j;

  for (i=0; i<8; i++) {
    for (j=0; j<4; j++) {
      printf("%4s %10s",idstr(i+(j*8)), valstr(&params[0],0,dump[i+(j*8)]) );
      if (j<3) printf("  |  ");  else printf("\n");
      }
    }

  printf("\n\n");

  for (i=0; i<8; i++) {
    for (j=0; j<4; j++) {
      printf("%4s %10s",idstr(i+32+(j*8)), 
	     valstr(&params[0],0,dump[i+32+(j*8)]) );
      if (j<3) printf("  |  ");  else printf("\n");
      }
    }
}


/****************************************************************/
MultiDir()
{
  /* prints the directory of Multis in this file */

  int i,j;

  for (i=0; i<8; i++) {
    for (j=0; j<4; j++) {
      printf("%4s %10s",idstr(i+(j*8)), valstr(&mparams[0],0,mdump[i+(j*8)]));
      if (j<3) printf("  |  ");  else printf("\n");
      }
    }
}