/* The usual Arp CLI interface data. */

char *CLI_Template	= "FILE/A,DRIVE/A,NOCLEAR/S";
char *CLI_Help		= "\nUsage: CompDisk [FILE <FileName>] [DRIVE <DF0:, DF1:, RAD:, etc.>] [NOCLEAR]\n";

	/* Argument vector offsets. */

#define ARG_FILE	1
#define ARG_DRIVE	2
#define ARG_NOCLEAR	3

	/* Some constants useful when playing with the disk. */

#define NUMBLOCKS	(80 * 2 * NUMSECS)
#define ROOTBLOCK	(NUMBLOCKS / 2)
#define LWORDS		(NUMBLOCKS / 32)
#define TRACKSIZE	(TD_SECTOR * NUMSECS * 2)
#define EXTRA		(2 * 16)
#define EXTRASIZE	(2 * (TD_SECTOR * NUMSECS + 16))

	/* Punches a string into the window. */

#define Punch(s)	Text(RPort,s,strlen(s))

	/* Function prototypes. */

VOID			Announce(VOID);
LONG __regargs		DoBlockCrc(UBYTE *,LONG);
LONG			Inhibit(char *,LONG);
UBYTE *			B2C(UBYTE *,BSTR);
LONG			DriverAction(LONG,LONG *,LONG);
VOID __regargs		ClearTrack(UBYTE *,LONG);
ULONG __regargs		CheckSum(ULONG *);
LONG			GetBitmap(struct CompInfo *);
LONG			MakeID(char *);
LONG			GetFileSize(char *);
LONG			ReadDump(char *,char *);
LONG			FindDevice(char *);
VOID			EraseGadget(struct RastPort *,struct Gadget *,LONG);
LONG			GetChangeCount(LONG);
VOID __regargs		ClearMem(char *,LONG);

LONG			CXBRK(VOID);
VOID __stdargs		main(LONG,char **);

	/* These are imported from CompSub.c */

VOID			compexit(VOID);
LONG			compinit(VOID);
LONG __regargs		compfiles(unsigned char *,LONG,unsigned char *,LONG);

	/* Global data. */

struct IOExtTD		*DiskRequest;
struct MsgPort		*DiskPort;
struct Library		*ReqBase;
struct Library		*IconBase;
extern struct ExecBase	*SysBase;
struct TextFont		*TextFont;
LONG			 ClearBlocks = TRUE;
LONG			*Sector,*ChipSector;
BYTE			 BlockTab[NUMBLOCKS + 2];
UBYTE			 Legal[5];
LONG			 ChangeCount[4];
struct IntuiMessage	*Massage;
struct Gadget		*Gadget;
LONG			 Class,Code,DriveWanted = -1;

	/* Program version & dump file ID. */

#define PRGVERSION	6
#define PROGRAMID	"COMP"

	/* This is the format of the standard dump file header. */

struct CompInfo
{
	LONG	ci_ProgramID;	/* Dump file ID. */
	LONG	ci_Version;	/* Version of program file was created with. */
	LONG	ci_Compression;	/* Compression mode. */
	ULONG	ci_ExtFlags;	/* Various extension flags. */
};

	/* This gets set in CompInfo . ci_ExtFlags if disk has a root-block. */

#define CI_HASROOT	0x00000001

	/* This follows a bunch of gadget definitions. */

struct TextAttr TxtAttr = {(UBYTE *)"topaz.font",8,0,65};

struct IntuiText BoxIntTxt[6] =
{
	{1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"RAD: ",		(struct IntuiText *)NULL},
	{1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF3: ",		(struct IntuiText *)NULL},
	{1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF2: ",		(struct IntuiText *)NULL},
	{1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF1: ",		(struct IntuiText *)NULL},
	{1,0,JAM1,24,  3,&TxtAttr,(UBYTE *)"DF0: ",		(struct IntuiText *)NULL},
	{1,0,JAM2,36,-11,&TxtAttr,(UBYTE *)"  Pathname ",	(struct IntuiText *)NULL}
};

UBYTE StrInfStr[160];
UBYTE UndoStrInfStr[160];

struct StringInfo BoxStrInf = {&StrInfStr[0],&UndoStrInfStr[0],0,160,23,0,0,0,0,NULL,NULL,NULL};

SHORT BoxBrdDat[] =
{
	-1,-1,88,-1,88,14,-1,14,-1,0,
	-2,-1,89,-1,89,14,-2,14,-2,-1,
	-1,-1,88,-1,88,14,-1,14,-1,0,
	-2,-1,89,-1,89,14,-2,14,-2,-1,
	-1,-1,88,-1,88,14,-1,14,-1,0,
	-2,-1,89,-1,89,14,-2,14,-2,-1,
	-1,-1,88,-1,88,14,-1,14,-1,0,
	-2,-1,89,-1,89,14,-2,14,-2,-1,
	-1,-1,88,-1,88,14,-1,14,-1,0,
	-2,-1,89,-1,89,14,-2,14,-2,-1,
	-1,-1,88,-1,95,-1,184,-1,184,8,95,8,88,8,-1,8,-1,-1,
	-2,-1,185,-1,185,8,-2,8,-2,-1,
};

struct Border BoxBrd[] =
{
	{0,0,1,0,0,5,&BoxBrdDat[  0],&BoxBrd[1]},
	{0,0,1,0,0,5,&BoxBrdDat[ 10],NULL},
	{0,0,1,0,0,5,&BoxBrdDat[ 20],&BoxBrd[3]},
	{0,0,1,0,0,5,&BoxBrdDat[ 30],NULL},
	{0,0,1,0,0,5,&BoxBrdDat[ 40],&BoxBrd[5]},
	{0,0,1,0,0,5,&BoxBrdDat[ 50],NULL},
	{0,0,1,0,0,5,&BoxBrdDat[ 60],&BoxBrd[7]},
	{0,0,1,0,0,5,&BoxBrdDat[ 70],NULL},
	{0,0,1,0,0,5,&BoxBrdDat[ 80],&BoxBrd[9]},
	{0,0,1,0,0,5,&BoxBrdDat[ 90],NULL},
	{0,0,1,0,0,9,&BoxBrdDat[100],&BoxBrd[11]},
	{0,0,1,0,0,5,&BoxBrdDat[118],NULL},
};

struct Gadget BoxGad[6] =
{
	{&BoxGad[1],  6,71, 88,14,0,  3,1,(APTR)&BoxBrd[ 0],NULL,&BoxIntTxt[0],NULL,NULL,		0,NULL},
	{&BoxGad[2],102,53, 88,14,0,  3,1,(APTR)&BoxBrd[ 2],NULL,&BoxIntTxt[1],NULL,NULL,		1,NULL},
	{&BoxGad[3],  6,53, 88,14,0,  3,1,(APTR)&BoxBrd[ 4],NULL,&BoxIntTxt[2],NULL,NULL,		2,NULL},
	{&BoxGad[4],102,35, 88,14,0,  3,1,(APTR)&BoxBrd[ 6],NULL,&BoxIntTxt[3],NULL,NULL,		3,NULL},
	{&BoxGad[5],  6,35, 88,14,0,  3,1,(APTR)&BoxBrd[ 8],NULL,&BoxIntTxt[4],NULL,NULL,		4,NULL},
	{NULL,        6,23,184, 8,0,515,4,(APTR)&BoxBrd[10],NULL,&BoxIntTxt[5],NULL,(APTR)&BoxStrInf,	5,NULL}
};

	/* The window title (gets filled in later). */

UBYTE WindowName[20];

	/* The new window definition. */

struct NewWindow NewWindow =
{
	0,11,
	196,88,
	-1,-1,
	CLOSEWINDOW | DISKINSERTED | GADGETUP,
	ACTIVATE | RMBTRAP | WINDOWDRAG | WINDOWCLOSE | WINDOWDEPTH,
	(struct Gadget *)&BoxGad[0],
	(struct Image *)NULL,
	WindowName,
	(struct Screen *)NULL,
	(struct BitMap *)NULL,
	0,0,
	0,0,
	WBENCHSCREEN
};

	/* Some window interface data. */

struct Window	*Window;
struct RastPort	*RPort;

	/* All five supported drives. */

char *Drives[5] =
{
	"RAD:",
	"DF3:",
	"DF2:",
	"DF1:",
	"DF0:"
};

	/* Icon definition, image 1. */

USHORT Image1Data[126] =
{
	/* Plane 0 */

	0x001F,0xFFFF,0x0000,0x001F,0xFF07,0x0000,0x001F,0xFF07,
	0x0000,0x001F,0xFF07,0x0000,0x001F,0xFF07,0x0000,0x001F,
	0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x00FF,0xF7F7,
	0xE000,0x00FF,0xEFFB,0xE000,0x00FF,0xDFFD,0xE000,0x00FF,
	0xAFFE,0xE000,0x00FF,0x7FFF,0xE000,0x00FE,0xFFFF,0xE000,
	0x00FD,0xFFFF,0xE000,0x00FB,0xFFFF,0xE000,0x00F7,0xFFFF,
	0xE000,0x00EF,0xFFFF,0xE000,0x0000,0x0000,0x0000,

	/* Plane 1 */

	0x7FE0,0x0000,0xFF80,0xFFE0,0x00F8,0xFFC0,0xFFE0,0x00F8,
	0xFFE0,0xFFE0,0x00F8,0xFFE0,0xFFE0,0x00F8,0xFFE0,0xFFE0,
	0x0000,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,
	0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFF3E,0xFCF8,
	0x1FE0,0xFF7D,0xFE7C,0x1FE0,0xFFFB,0xFF3E,0x1FE0,0xFFF7,
	0xDF9F,0x1FE0,0xFFEF,0x8000,0x1FE0,0xFFDF,0x0000,0x1FE0,
	0xE3BE,0x0000,0x1FE0,0xE37C,0x0000,0x1FE0,0xFFF8,0x0000,
	0x1FE0,0x7FF0,0x0000,0x1FC0,0x0000,0x0000,0x0000
};

struct Image Image1 =
{
	0,0,
	43,21,2,
	(USHORT *)&Image1Data[0],
	0x03,0x00,
	(struct Image *)NULL
};

	/* Icon definition, image 2. */

USHORT Image2Data[126] =
{
	/* Plane 0 */

	0x07FF,0xFFC0,0x0000,0x07FF,0xD5C0,0x0000,0x07FF,0xEBC0,
	0x0000,0x07FF,0xD5C0,0x0000,0x07FF,0xEBC0,0x0000,0x07FF,
	0xFFC0,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x00FF,0xF7F7,
	0xE000,0x00FF,0xEFFB,0xE000,0x00FF,0xDFFD,0xE000,0x00FF,
	0xAFFE,0xE000,0x00FF,0x7FFF,0xE000,0x00FE,0xFFFF,0xE000,
	0x00FD,0xFFFF,0xE000,0x00FB,0xFFFF,0xE000,0x00F7,0xFFFF,
	0xE000,0x00EF,0xFFFF,0xE000,0x0000,0x0000,0x0000,

	/* Plane 1 */

	0x7800,0x003F,0xFF80,0xF800,0x3E3F,0xFFC0,0xF800,0x3E3F,
	0xFFE0,0xF800,0x3E3F,0xFFE0,0xF800,0x3E3F,0xFFE0,0xF800,
	0x003F,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,
	0xFFFF,0xFFFF,0xFFE0,0xFFFF,0xFFFF,0xFFE0,0xFF3E,0xFCF8,
	0x1FE0,0xFF7D,0xFE7C,0x1FE0,0xFFFB,0xFF3E,0x1FE0,0xFFF7,
	0xDF9F,0x1FE0,0xFFEF,0x8000,0x1FE0,0xFFDF,0x0000,0x1FE0,
	0xE3BE,0x0000,0x1FE0,0xE37C,0x0000,0x1FE0,0xFFF8,0x0000,
	0x1FE0,0x7FF0,0x0000,0x1FC0,0x0000,0x0000,0x0000
};

struct Image Image2 =
{
	0,0,
	43,21,2,
	(USHORT *)&Image2Data[0],
	0x03,0x00,
	(struct Image *)NULL
};

	/* The tooltypes entries for this icon. */

char *ToolTypes[] =
{
	"FILETYPE=COMPDISK",
	NULL
};

	/* The icon data itself. */

struct DiskObject ProjectIcon =
{
	WB_DISKMAGIC,
	WB_DISKVERSION,

	(struct Gadget *)NULL,
	0,0,
	43,21,
	GADGIMAGE | GADGHIMAGE,
	RELVERIFY | GADGIMMEDIATE,
	BOOLGADGET,
	(APTR)&Image1,
	(APTR)&Image2,
	(struct IntuiText *)NULL,
	NULL,
	(APTR)NULL,
	NULL,
	(APTR)NULL,

	WBPROJECT,
	"SYS:System/DecompDisk",
	ToolTypes,
	NO_ICON_POSITION,
	NO_ICON_POSITION,
	(struct DrawerData *)NULL,
	(char *)NULL,
	10000
};

	/* This macro saves the icon to a named file. */

#define SaveProjectIcon(Destination) PutDiskObject(Destination,&ProjectIcon)

	/* This macro sets the "busy" pointer for a window. */

#define SetWait(Window) SetPointer(Window,ElecArtsWaitPointer,22,16,0,0)

	/* The mouse pointer definition. */

USHORT __chip ElecArtsWaitPointer[(22 * 2) + 4] =
{
	0x0000,0x0000,

	0x6700,0xC000,
	0xCFA0,0xC700,
	0xBFF0,0x0FA0,
	0x70F8,0x3FF0,
	0x7DFC,0x3FF8,
	0xFBFC,0x7FF8,
	0x70FC,0x3FF8,
	0x7FFE,0x3FFC,
	0x7F0E,0x3FFC,
	0x3FDF,0x1FFE,
	0x7FBE,0x3FFC,
	0x3F0E,0x1FFC,
	0x1FFC,0x07F8,
	0x07F8,0x01E0,
	0x01E0,0x0080,
	0x07C0,0x0340,
	0x0FE0,0x07C0,
	0x0740,0x0200,
	0x0000,0x0000,
	0x0070,0x0020,
	0x0078,0x0038,
	0x0038,0x0010,

	0x0000,0x0000
};

	/* Announce():
	 *
	 *	Beeps thrice (Shakespeare is dead) to indicate special
	 *	program conditions.
	 */

VOID
Announce()
{
	static UBYTE AnyChannel[4] = {1,2,4,8};

	static ULONG __chip SoundData[1086] =
	{
		0xFAF5F4D0,0xCF1720E4,0xEF1F1F3F,0x6410EF4F,0x7008F6F0,0xBCEF28C0,
		0x80BF00C8,0xEFE09FFF,0x7F60E73F,0x78657F60,0xA8DF7B00,0x809B8083,
		0xFF008083,0x3F400F3E,0x00FF7F7F,0x20FF7D50,0x2F408080,0xDF208080,
		0x8F87DF5E,0xE0803F7F,0x606B7010,0x7F7F6080,0xEF20D0DF,0xA0808137,
		0xD0809FF8,0x0F7F7FD0,0xFF7F7F40,0x4800DB77,0x608080BF,0xC08FB280,
		0x801F7FC0,0xBF5F677F,0x7F60BF7F,0x7F20CBD0,0x80AF3680,0x808300C8,
		0xCFC08FFF,0x7F78EB37,0x7F7F7F7E,0xE0FF7F60,0xC0A7A097,0xF7E08080,
		0xBFE8B0BF,0xA4BF7F7F,0x20FF7F7F,0x7F7F40D7,0x6F7F1097,0xB3A0BFF8,
		0x808081FF,0xC0A7B59F,0xFF7F70D8,0x3F7F7F7F,0x7800FF7F,0x70C09FC0,
		0xB7E7C080,0x80DF0090,0x9FB0CF6F,0x7F00DF7F,0x7F7F7828,0x0F6F7F20,
		0xA0AFCFE2,0xD0808083,0xF7D0949B,0xBF2F7F40,0xF02F7F7F,0x7F50123F,
		0x7F60C89F,0xCFE5E0A0,0x8080CFF0,0xA085B7FF,0x5F7000FF,0x777F7F60,
		0x282F7F7F,0x1097BFEB,0xE4C08080,0x8FFBC080,0x97DF2F6C,0x30E9377F,
		0x7F70402F,0x5F7F50C0,0xAFDFF8D0,0x888080D7,0xE0A081BF,0x0F4F4000,
		0xFF7F7F7F,0x48304F7F,0x7800A9CF,0xFFE8A880,0x80AFEEC0,0x809FEF37,
		0x4818F73F,0x7F7F6032,0x3F6F7F40,0xC0BBFB00,0xC0808087,0xDFD88881,
		0xBF1F3F28,0xF40F7F7F,0x78403B5F,0x7F7000AF,0xDF08E0A0,0x8080BFDA,
		0xA8809FF7,0x2F2800FF,0x3F7F7F50,0x304F7F78,0x30D0CFFF,0x04C08080,
		0x9FD7C080,0x87CF1F2E,0x08F71F7F,0x7F68303F,0x777F6000,0xCBEF14E0,
		0x908083BF,0xD0A0809F,0xFF2B14F4,0xFF4F7F7E,0x4033677F,0x7420D0DF,
		0x1300C080,0x81B7D3B0,0x808FD71B,0x2000F72F,0x7F7F602D,0x4F7F7E48,
		0xF0DFFF14,0xE090809F,0xCFC89080,0xAFFF2000,0xEE0F577F,0x70343B6F,
		0x7F6810E1,0xF71B00B0,0x808BBFD0,0xA8808FDF,0x1908EAF7,0x2F7F7E48,
		0x2D577F7C,0x40F0EF17,0x18E09083,0xAFD1C084,0x80BFFF10,0xF2EB0F5F,
		0x7E60303F,0x777F6010,0xF1072100,0xB0889FCF,0xC8A0809F,0xDF0F00E1,
		0xFB377768,0x402F5F7F,0x7428F8FF,0x1F14D094,0x93BFD2B0,0x8487BFFF,
		0x04E2E71B,0x5F74502B,0x477F7F48,0x08FD1724,0x00B08FAF,0xD5C49080,
		0x9FEF08EC,0xDEFF3F6A,0x5832375F,0x7F682401,0x0F2710D0,0xA0A7CBD0,
		0xA8818FCF,0xFDF4D8E7,0x1F5B6040,0x2D4F7F7C,0x40100B27,0x24F0B09F,
		0xBFD6C088,0x83AFEBF8,0xE0D7FF3F,0x61482C3F,0x6F7F6020,0x0B1F3010,
		0xD0A2B7D7,0xCCA08097,0xCFF7E4CE,0xE71F5B54,0x322F5F7F,0x74401017,
		0x2F20F0B4,0xADCFD8B8,0x8887B7EB,0xECD1D7FF,0x3F544029,0x3F777F60,
		0x20152D34,0x08C8AEBF,0xDBC89881,0x9FD7EED8,0xCBEF2B4F,0x42282F5F,
		0x7F703416,0x273C20E8,0xB5BBD7D8,0xA8828FBF,0xE9E0C6CF,0x0F3F4C30,
		0x27477B78,0x50241F39,0x3000D0BB,0xCFDAC090,0x87A7D7E0,0xCCCBEF2F,
		0x4638263B,0x677E6030,0x21333C20,0xE0C0C7DD,0xD0A88597,0xBFDFD0C2,
		0xD7173F3C,0x262D4F7B,0x7440242F,0x3F3000CC,0xC7DBDCC0,0x8C8FAFD7,
		0xD4C0C7FF,0x2F3C2823,0x3F6F7A58,0x302A3F40,0x18E0C7D7,0xDFC8A08D,
		0x9FC7D4C4,0xBFDF1733,0x2C202F5B,0x7668402E,0x3B463000,0xD4D7E3D8,
		0xB49097B7,0xD1C6B9CB,0xFF272C20,0x23476F70,0x5034394A,0x4010E0D5,
		0xE3E2C4A0,0x8FA7C7CA,0xB8BBDF0F,0x2B201B37,0x5F756040,0x37475028,
		0xF4D9DFE6,0xD0A8909F,0xBDC8BCB5,0xCFFF1F22,0x1B274F6F,0x68503A43,
		0x504008E4,0xDFE8E0C0,0x9895AFC7,0xC0B1BFE7,0x1722181D,0x3B677058,
		0x403F4F4C,0x28F2E0E7,0xE9D0A892,0xA7BFC4B4,0xB3D7FF1F,0x1A142B4F,
		0x6F60443A,0x4B544008,0xE6E7F0E4,0xC0969DBB,0xC7BAADBF,0xEF131A10,
		0x1B3F5F64,0x503C4756,0x4A20F8EC,0xF3F0D0A8,0x9DAFC4C0,0xAEB3D7FF,
		0x150C0F2B,0x4F655840,0x3F535840,0x10F2F5F8,0xE2B89DA7,0xBFC0B0A7,
		0xBFEF0B0C,0x06173F5F,0x6048414F,0x5F502000,0xF8FCF0D0,0xA49FB5BF,
		0xB0A3AFCF,0xFF0A060F,0x2F556054,0x454B5B58,0x340CFCFD,0xF8E0B8A2,
		0xAFBFB9A8,0xA7BFEF05,0x04051F3F,0x5D564447,0x575E4820,0x020000F0,
		0xC8AAADBD,0xC0B0A3B7,0xDBFB00FD,0x0B2F5356,0x48414F5F,0x58300C04,
		0x0700E0B8,0xABB9C3B8,0xA1A7BFED,0xFCF8FF1B,0x3F564C40,0x495D6040,
		0x200B0B06,0xF0C8B2B6,0xBFBAA89F,0xB7DBF3F4,0xF70B2F4F,0x50424557,
		0x62543011,0x0D0D00D8,0xB8B5BFC0,0xB0A0ABCF,0xEBF3F3FF,0x1F475042,
		0x3D4F5F5A,0x40180C11,0x08E8C4B7,0xBFC6C0A8,0xA5BFDFF2,0xF0F70F2F,
		0x4B44383F,0x575C4828,0x13131100,0xD4C0BFC6,0xC2B0A4B7,0xD7E9ECEF,
		0xFF1F3D42,0x383B4F5C,0x50382013,0x180CE8CC,0xC4C9CAC0,0xA8A9C7DF,
		0xE8E7F30F,0x2B3E3631,0x3F575844,0x2A1A1E1C,0x00DACCCD,0xCFC6B0A4,
		0xB7D7E1E0,0xE7FD1B35,0x362E374F,0x5C503822,0x212410EC,0xD4D0D0C8,
		0xB8A6ABC7,0xD9DADFEF,0x0B273430,0x33475B58,0x48322728,0x2000E0D5,
		0xD3CCC0AC,0xA3B7CFD5,0xD4DFFB17,0x2D302E3F,0x5A605440,0x302E2C18,
		0xF0D8D5D0,0xC4B0A0A7,0xBFCFCDD3,0xEB071F32,0x2E374F66,0x60503A31,
		0x322800E0,0xD6D2C8B8,0xA29AAFC7,0xCBCBDDFB,0x172F3232,0x47656858,
		0x44383430,0x14E8D6D4,0xCCBCA899,0x9FBFCBC9,0xD3EF0F2B,0x34333D5B,
		0x6A604839,0x343020F8,0xD8D2D2C6,0xB2A09FB7,0xCBCECEDF,0xFF1F2F2E,
		0x2F475F60,0x503A3535,0x2C0CE8D9,0xDAD4C0AA,0xA0AFBFCC,0xC8CFEF0D,
		0x23272737,0x57625844,0x3A3B3820,0x00E2DFDE,0xD0B8A4A7,0xBBC7C5C6,
		0xDBFB161F,0x212B475D,0x5C4C3E3F,0x403410F2,0xE7E7DCC4,0xACA5AFBF,
		0xC2BDC7DF,0xFF191A1F,0x35576158,0x48424745,0x2800EEE9,0xE4D0B4A0,
		0xA5B7BEB8,0xBBCFEF13,0x1A19274D,0x63615246,0x494D4014,0xF4ECE8DC,
		0xC0A49DAF,0xBBB8B3BF,0xDFFF1B1A,0x1F3F5F64,0x5A4A474C,0x482000EB,
		0xEAE0CCB0,0x9EA7BBBE,0xB6BFD7FB,0x161A192B,0x4F5F5848,0x41454830,
		0x0AF2EFEE,0xE0C2ACAB,0xBDC6BCB7,0xCBE70712,0x0E153753,0x54463E43,
		0x4B442000,0xF8FCF0D8,0xC0AFB9C5,0xC0B1B7D3,0xEF030407,0x1F3F524A,
		0x40454F50,0x38180303,0x00ECCCB5,0xB7C2C0B2,0xADBFDFF7,0xFCFB0B2F,
		0x474C403F,0x4F5A4C2C,0x10090C00,0xE0C0B5BF,0xC3B8A6AF,0xCBEBF7F6,
		0xFD1B3F4D,0x443C475A,0x5A40200E,0x0F0CF0D0,0xB8BBC3C0,0xA8A3B7DB,
		0xEFF0F307,0x2F47483C,0x3F555D50,0x30140F12,0x00E0C0BB,0xC3C2B4A4,
		0xAFCFEDF1,0xF0FB1B3B,0x49403947,0x5B584020,0x0F1310F4,0xD0BFC5CB,
		0xC4B0A7BF,0xDFF0EBEE,0xFF273F40,0x30374F5A,0x48301819,0x1E10E8CA,
		0xCBD1CCB8,0xA6AFCBE5,0xE2DFEF0F,0x2F3B3133,0x475F5840,0x28202420,
		0x00D8CBCF,0xCCC0A8A1,0xB7D7DEDB,0xE3FF1F37,0x39353F5B,0x62503425,
		0x24200CE4,0xC8C9CCC0,0xA89FABC7,0xDDDDDFF7,0x17353C37,0x3F53645A,
		0x40282323,0x14F0D0C7,0xCDC8B4A0,0xA3BBD7DE,0xDBE7FF2B,0x3A39394B,
		0x5F644830,0x28272004,0xE0C9CDCA,0xBAA29FAF,0xC7DBD8DF,0xFB1F353A,
		0x38435F69,0x58402C2A,0x2410E8CC,0xC7CDC0AC,0x9CA7BFD7,0xDCDBEF0F,
		0x2F3A3639,0x4F656048,0x2C272718,0xF8D8C9CE,0xCAB8A29F,0xBBD3DEDB,
		0xE7FF2535,0x34343F5B,0x60503227,0x27200AE4,0xD0D1D4C4,0xB0A4AFCB,
		0xDAD9DBF3,0x0F272F2F,0x374D5E54,0x40302D28,0x1800DCD4,0xD7D0B8A8,
		0xAABBD3D7,0xD5DFFF1F,0x2B2D313F,0x575C4832,0x2E2C2208,0xEAD6D9D8,
		0xC0ACA8B5,0xCBD7D4D7,0xF7152327,0x2B374B5B,0x50383031,0x2A1800E2,
		0xDBDED0B8,0xABAFBFCF,0xD4D3DFFF,0x1B21252F,0x3F535640,0x34343220,
		0x08F0E0E0,0xDCC4B0AF,0xBAC7D1CF,0xD7EF0F1D,0x1F27374B,0x59503835,
		0x38301800,0xE5E1E1D0,0xB8ABB3BF,0xCFD0CFDF,0xFF1B1F23,0x2D3F5554,
		0x40313432,0x2004ECE1,0xE4E0C4B0,0xB3BFCDD3,0xD0D7F713,0x1B1C2335,
		0x47524832,0x32372C14,0x00EAE8E9,0xD8C0B3BD,0xC9CFCCCC,0xDFFF1512,
		0x17273F4F,0x4C38313B,0x3C2408F6,0xEEF0E8C8,0xB1B7C7CC,0xC8C6CFEF,
		0x0E100D1B,0x37494E42,0x363B4438,0x1800F7F4,0xECD8B8AF,0xBDC5C2BE,
		0xC5DDFF0F,0x0C132B47,0x5350423C,0x45442808,0xF8F1ECDC,0xC0A8AFBF,
		0xC2BDBFD3,0xEF0F1613,0x253F5354,0x483C3D43,0x3410F5EE,0xEAE0CCB0,
		0xABBFCBC7,0xC4CFEB0B,0x1B16192F,0x4B4E4438,0x30373820,0xF8EDEFEB,
		0xDCC4B5BF,0xD5D4CCCF,0xDFFF1314,0x0C1B3742,0x3C30282D,0x362808F8,
		0xFAFAF0E0,0xC6C3D5D9,0xCDC7D5E7,0xFF090107,0x1F393A35,0x31323D40,
		0x24080303,0xFCE8D0BE,0xC7D2C8BE,0xC3D7EBFF,0x02FF1537,0x403E3B37,
		0x3F473814,0x060400F0,0xD8C0BBCB,0xCABDBDCB,0xDFF70501,0x0B273F41,
		0x3E3A3B44,0x40200803,0x00F4E2CA,0xBABFCEC4,0xBDC7D7EF,0xFF060517,
		0x373F3E3A,0x373D4334,0x120501FC,0xF0D8C2BF,0xCFCEC2BF,0xCDDFFB03,
		0x00071F3B,0x3E38353B,0x4540220C,0x0605FCE8,0xCCC0C9CF,0xC6BCBFD7,
		0xEFFDFCFF,0x17333F3C,0x34374545,0x32180806,0x03F2D8C4,0xC7CECAC0,
		0xBDCBE7FB,0xFDFF0D27,0x3B3D3534,0x3F463A20,0x0A0505FA,0xE0CAC7CF,
		0xD0C8BEC7,0xDFF7FDFC,0x031B333C,0x342D3743,0x40281007,0x0804F0D4,
		0xC8CFD7D0,0xC0BFCFED,0xFBF7F707,0x2737352B,0x2F3F4838,0x200D0D0E,
		0x00E4CDCF,0xD7D4C4B9,0xBFDBEFF4,0xF0FB172F,0x38302E3B,0x4B483018,
		0x11120AF4,0xD4C8CFD3,0xC8B6B7CB,0xE7F3F0F5,0x0B2B3B38,0x3037474E,
		0x40201011,0x0E00E0C8,0xCBD3CEBC,0xB6BFDFF5,0xF5F5FF1F,0x3738302F,
		0x3B484024,0x100D0E04,0xECD2CDD7,0xD8CCBEBF,0xD7EFF5F1,0xF70F2731,
		0x2C262F3F,0x40301A12,0x131000E4,0xD6DADDD4,0xC4BFCBDF,0xEEEBEFFF,
		0x17272822,0x293B4238,0x24191819,0x0CF2E0DD,0xDFDACCBD,0xBFD7E7E6,
		0xE6F30B1F,0x27222335,0x43403020,0x1C1F1800,0xE8E0E2E0,0xD2C1BFCF,
		0xDFE4E1E9,0xFD131F20,0x1E2B3D40,0x34281E1F,0x2010F8E6,0xE6E4DCCC,
		0xC0C7D7E2,0xE0E1EFFF,0x171E1A1F,0x333F3A30,0x2420241C,0x02F0E9E8,
		0xE1D6C2BE,0xCFDFDCDA,0xE5FB0F1D,0x1A192B3F,0x40362A22,0x252810F8,
		0xECECE8E0,0xCCBEC7DB,0xE0D8DDEF,0xFF151A13,0x1D333E36,0x2C242226,
		0x2002F0F1,0xF0E8D8CA,0xC7D5E2DC,0xD9E5F907,0x0F100F1F,0x35342925,
		0x24272614,0x00F8FCF4,0xE4D4CCCF,0xDEDDD4D9,0xEFFE070A,0x0A172F37,
		0x2E282A2D,0x2C200AFD,0xFFFAEAD8,0xCCCBD5D8,0xD0CFDFF3,0xFF070913,
		0x27393630,0x2D2F3129,0x1400FCFA,0xF0E0D0C8,0xCED8D6D0,0xD9EFFF07,
		0x0C0F1D2F,0x38302A2A,0x2C292008,0xFAFCF8E8,0xD8CFCFDB,0xDED6D7EB,
		0xFB030909,0x0F23312C,0x2525272A,0x241000FF,0x00F4E4D8,0xD3DAE1D8,
		0xD2DDEFFB,0x01030617,0x2B2C2425,0x292B2A1C,0x08030600,0xECE0D6D6,
		0xDEDCD1D5,0xE7F4FBFF,0x030D1F2C,0x26262A2C,0x2B241404,0x0603F4E4,
		0xDCD6D7DC,0xD6D2DFEF,0xF7FE0309,0x17272823,0x272B2925,0x1A0A0306,
		0x00E8E0DB,0xDADEDCD5,0xDBEDF7FB,0xFF070F1F,0x28212127,0x28231C0D,
		0x010500F0,0xE4E1DEDF,0xE2DCDAE7,0xF7FBFF05,0x09172320,0x1B1F2621,
		0x1A120501,0x04FAEAE6,0xE5E3E4E4,0xE0E6F7FC,0xFC02090E,0x191E1817,
		0x1F201812,0x0A030402,0xF4EAECEC,0xE8E7E4E3,0xEFF9F9F8,0xFF070F17,
		0x18151B24,0x2018120C,0x0A0A00F0,0xEAEBE8E3,0xDEDCE3EF,0xF6F5FA03,
		0x0F171D1B,0x1D262920,0x18100A07,0x02F4E6E5,0xE6E0DCDB,0xDDE7F6FA,
		0xF9FF0F19,0x1F211F21,0x2A24160F,0x0A0300F8,0xE8E0E6E6,0xDEDDDFE5,
		0xF5FFFCFD,0x0D171B1F,0x1C191F26,0x180C0A07,0x0200F4E6,0xE9EEE8E0,
		0xE1E5EEFA,0xFAF7FF0F,0x13141616,0x1B232012,0x0F100C07,0x00F2EDF1,
		0xECE1DEE0,0xE3EFF2EF,0xF5030D0F,0x15181B26,0x281C1618,0x140C04F8,
		0xEEEFECE0,0xD8DBDFE5,0xEFEEEFFF,0x0E10131A,0x1F252B22,0x18191810,
		0x05FCF0ED,0xEEE4D8D9,0xDFE5EDEE,0xEFFB0D12,0x14171D23,0x29221814,
		0x150E04FA,0xF0EDEEE8,0xDEDBE1E7,0xEEF3F3FB,0x0B121114,0x191E2322,
		0x16111310,0x04FCF6F0,0xF1F0E4DF,0xE5EBEEF2,0xF4F9030E,0x0D0D1318,
		0x1C1D1810,0x11130C00,0xFCF8F7F6,0xF0E4E5EB,0xEDEEEFF1,0xF9030806,
		0x0911171B,0x1A141318,0x160C0400,0xFDFBF5EA,0xE3E7E9E7,0xE8EBEFF9,
		0x0202050F,0x171C1F20,0x1B1E1F15,0x0B0600FA,0xF4EAE0DE,0xE2E1DFE5,
		0xEBF3FF07,0x070F1C21,0x2324211E,0x1F1A0C02,0x00F8F1EA,0xE0DADFE2,
		0xE1E3EBF3,0xFF070B0E,0x171F2324,0x221C1B1A,0x1003FEF9,0xF3ECE5DD,
		0xDDE3E5E6,0xEBF1FB05,0x0B0C111B,0x2020201C,0x18191508,0x00FCF8F2,
		0xECE4DFE3,0xE7E7E7ED,0xF5FF070A,0x0C131E20,0x1F1C1818,0x181001FC,
		0xFAF7F0E8,0xE1E1E7EA,0xE9EBF3FD,0x070C0C0F,0x1921201C,0x18161612,
		0x04FCF9F8,0xF3EDE6E2,0xE7EEEEEC,0xF2FB030B,0x0C0B0F1A,0x1B181411,
		0x11110A00,0xFCFBF9F6,0xF0E9EAEF,0xF0EFF1F6,0xFD050806,0x09111616,
		0x14100F13,0x100600FF,0xFFFCF8F0,0xECEEF2F0,0xEEEFF7FE,0x03030207,
		0x11151411,0x11131410,0x08010100,0xFCF4EDEB,0xEEEFECEC,0xEFF7FF02,
		0x01050E15,0x16151314,0x16140A04,0x0000FCF6,0xF0EAECEE,0xECEDEFF6,
		0xFD030306,0x0C121516,0x14121212,0x0C0400FF,0xFCF8F3ED,0xECEEEEEF,
		0xF1F5FBFF,0x0406090E,0x11131211,0x100F0C08,0x0200FFFC,0xF7F4F1F0,
		0xF1F2F2F5,0xF9FDFF04,0x05070B0F,0x0F10100D,0x0D0D0803,0x0100FCFB,
		0xF6F0F0F3,0xF3F3F6F7,0xFC020402,0x060B0E11,0x100C0B0E,0x0D070200,
		0xFEFEFBF2,0xEEF0F3F4,0xF4F4F7FF,0x05040309,0x0F121310,0x0C0F100B,
		0x0300FEFD,0xFCF4ECED,0xF2F4F2F3,0xF6FD0507,0x04070F14,0x14130F0E,
		0x110E04FE,0xFEFCF9F4,0xECEAEEF2,0xF1F2F6FD,0x050A090A,0x0F151614,
		0x100C0D0C,0x04FEFAF9,0xF8F6F0EC,0xEFF3F5F7,0xF9FD030A,0x0A090D11,
		0x1212100B,0x0A0A0500,0xFCFBF9F8,0xF4F0F1F5,0xF6F7F9FD,0x01050807,
		0x090D0F0D,0x0C0B0909,0x0702FFFE,0xFEFBF8F6,0xF4F5F8F7,0xF7FAFF00,
		0x03050407,0x0B0B0A0A,0x0A0A0B08,0x03010202,0x00FCF7F6,0xF8F7F5F4,
		0xF6FAFEFF,0xFEFF060B,0x0C0C0D0F,0x11100C08,0x060603FD,0xF7F4F3F3,
		0xF0EEEFF3,0xF9FBFDFF,0x030B0F0F,0x0F121615,0x120D0807,0x0600F6F1,
		0xF0EEEEEC,0xE9EFF7FB,0xFDFF050D,0x13151413,0x1716120C,0x0500FFFC,
		0xF4EEEDED,0xEEEFEFF1,0xF9FF0306,0x090E1216,0x14100F10,0x0C0701FD,
		0xFBFCF8F1,0xF0F1F2F4,0xF6F6F9FF,0x06060709,0x0C0F110D,0x0A0C0C08,
		0x0400FCFD,0xFDF6F2F3,0xF4F5F7F6,0xF6FE0304,0x0608090E,0x110E0A0B,
		0x0B080400,0xFBFAFCF9,0xF4F3F5F6,0xF8FAF9FD,0x03070708,0x090B0E0E,
		0x0A060706,0x0200FCF9,0xF9FBF9F6,0xF7F9FBFD,0xFFFF0307,0x09090808,
		0x08080704,0x010000FE,0xFCFBFBFC,0xFEFEFEFF,0x00010202,0x03030303,
		0x02000000,0xFF000000,0x00010203,0x03030305,0x040100FF,0xFDFDFDFC,
		0xFAFCFEFE,0xFFFFFF03,0x07070709,0x0A090A08,0x03030300,0xFBF8F6F5
	};

	struct IOAudio	*AudioBlock;
	struct MsgPort	*ReplyPort;

	if(AudioBlock = (struct IOAudio *)AllocMem(sizeof(struct IOAudio),MEMF_PUBLIC | MEMF_CLEAR))
	{
		if(ReplyPort = (struct MsgPort *)CreatePort(NULL,0))
		{
			AudioBlock -> ioa_Data						= &AnyChannel[0];
			AudioBlock -> ioa_Length					= 4;
			AudioBlock -> ioa_Request . io_Message . mn_ReplyPort		= ReplyPort;
			AudioBlock -> ioa_Request . io_Message . mn_Node . ln_Pri	= 90;

			if(!OpenDevice("audio.device",0,AudioBlock,0))
			{
				AudioBlock -> ioa_Request . io_Command	= CMD_WRITE;
				AudioBlock -> ioa_Request . io_Flags	= ADIOF_PERVOL;
				AudioBlock -> ioa_Period		= 428;
				AudioBlock -> ioa_Volume		= 64;
				AudioBlock -> ioa_Cycles		= 3;
				AudioBlock -> ioa_Data			= (UBYTE *)&SoundData[0];
				AudioBlock -> ioa_Length		= 4344;

				BeginIO(AudioBlock);
				WaitIO(AudioBlock);
				AbortIO(AudioBlock);

				CloseDevice(AudioBlock);
			}

			DeletePort(ReplyPort);
		}

		FreeMem(AudioBlock,sizeof(struct IOAudio));
	}
}

	/* DoBlockCrc(Mem,Size):
	 *
	 *	Calculates the 16-Bit CRC value for a given
	 *	memory block.
	 */

LONG __regargs
DoBlockCrc(Mem,Size)
register UBYTE *Mem;
register LONG Size;
{
	/* crctab calculated by Mark G. Mendel, Network Systems Corporation */

	static const unsigned short crctab[256] =
	{
		0x0000,0x1021,0x2042,0x3063,0x4084,0x50A5,0x60C6,0x70E7,
		0x8108,0x9129,0xA14A,0xB16B,0xC18C,0xD1AD,0xE1CE,0xF1EF,
		0x1231,0x0210,0x3273,0x2252,0x52B5,0x4294,0x72F7,0x62D6,
		0x9339,0x8318,0xB37B,0xA35A,0xD3BD,0xC39C,0xF3FF,0xE3DE,
		0x2462,0x3443,0x0420,0x1401,0x64E6,0x74C7,0x44A4,0x5485,
		0xA56A,0xB54B,0x8528,0x9509,0xE5EE,0xF5CF,0xC5AC,0xD58D,
		0x3653,0x2672,0x1611,0x0630,0x76D7,0x66F6,0x5695,0x46B4,
		0xB75B,0xA77A,0x9719,0x8738,0xF7DF,0xE7FE,0xD79D,0xC7BC,
		0x48C4,0x58E5,0x6886,0x78A7,0x0840,0x1861,0x2802,0x3823,
		0xC9CC,0xD9ED,0xE98E,0xF9AF,0x8948,0x9969,0xA90A,0xB92B,
		0x5AF5,0x4AD4,0x7AB7,0x6A96,0x1A71,0x0A50,0x3A33,0x2A12,
		0xDBFD,0xCBDC,0xFBBF,0xEB9E,0x9B79,0x8B58,0xBB3B,0xAB1A,
		0x6CA6,0x7C87,0x4CE4,0x5CC5,0x2C22,0x3C03,0x0C60,0x1C41,
		0xEDAE,0xFD8F,0xCDEC,0xDDCD,0xAD2A,0xBD0B,0x8D68,0x9D49,
		0x7E97,0x6EB6,0x5ED5,0x4EF4,0x3E13,0x2E32,0x1E51,0x0E70,
		0xFF9F,0xEFBE,0xDFDD,0xCFFC,0xBF1B,0xAF3A,0x9F59,0x8F78,
		0x9188,0x81A9,0xB1CA,0xA1EB,0xD10C,0xC12D,0xF14E,0xE16F,
		0x1080,0x00A1,0x30C2,0x20E3,0x5004,0x4025,0x7046,0x6067,
		0x83B9,0x9398,0xA3FB,0xB3DA,0xC33D,0xD31C,0xE37F,0xF35E,
		0x02B1,0x1290,0x22F3,0x32D2,0x4235,0x5214,0x6277,0x7256,
		0xB5EA,0xA5CB,0x95A8,0x8589,0xF56E,0xE54F,0xD52C,0xC50D,
		0x34E2,0x24C3,0x14A0,0x0481,0x7466,0x6447,0x5424,0x4405,
		0xA7DB,0xB7FA,0x8799,0x97B8,0xE75F,0xF77E,0xC71D,0xD73C,
		0x26D3,0x36F2,0x0691,0x16B0,0x6657,0x7676,0x4615,0x5634,
		0xD94C,0xC96D,0xF90E,0xE92F,0x99C8,0x89E9,0xB98A,0xA9AB,
		0x5844,0x4865,0x7806,0x6827,0x18C0,0x08E1,0x3882,0x28A3,
		0xCB7D,0xDB5C,0xEB3F,0xFB1E,0x8BF9,0x9BD8,0xABBB,0xBB9A,
		0x4A75,0x5A54,0x6A37,0x7A16,0x0AF1,0x1AD0,0x2AB3,0x3A92,
		0xFD2E,0xED0F,0xDD6C,0xCD4D,0xBDAA,0xAD8B,0x9DE8,0x8DC9,
		0x7C26,0x6C07,0x5C64,0x4C45,0x3CA2,0x2C83,0x1CE0,0x0CC1,
		0xEF1F,0xFF3E,0xCF5D,0xDF7C,0xAF9B,0xBFBA,0x8FD9,0x9FF8,
		0x6E17,0x7E36,0x4E55,0x5E74,0x2E93,0x3EB2,0x0ED1,0x1EF0
	};

	register unsigned short crc = 0;

	/*
	 * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell.
	 *  NOTE: First argument must be in range 0 to 255.
	 *        Second argument is referenced twice.
	 *
	 * Programmers may incorporate any or all code into their programs,
	 * giving proper credit within the source. Publication of the
	 * source routines is permitted so LONG as proper credit is given
	 * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
	 * Omen Technology.
	 */

	while(Size-- > 0)
		crc = crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ *Mem++;

	return((LONG)crc);
}

	/* Inhibit(DriveID,Code):
	 *
	 *	Gives the Disk-Validator access to a disk drive
	 *	or doesn't.
	 */

LONG
Inhibit(DriveID,Code)
char *DriveID;
LONG Code;
{
	struct MsgPort	*HandlerTask;
	LONG		 Args[7];

	if(!(HandlerTask = (struct MsgPort *)DeviceProc(DriveID)))
		return(FALSE);

	Args[0] = Code;

	return(SendPacket(ACTION_INHIBIT,Args,HandlerTask));
}

	/* B2C(to,from):
	 *
	 *	Converts a BSTR into a 'C'-String.
	 */

UBYTE *
B2C(to,from)
UBYTE *to;
BSTR from;
{
	UBYTE length = *((UBYTE *)BADDR(from));
	UBYTE *src = (UBYTE *)BADDR(from) + 1;

	while(length--)
		*to++ = *src++;

	*to = NULL;

	return(to);
}

	/* DriverAction(Command,Dest,Track):
	 *
	 *	Lets the current unit driver take some action.
	 */

LONG
DriverAction(Command,Dest,Track)
LONG Command,*Dest,Track;
{
	DiskRequest -> iotd_Req . io_Command	= Command;
	DiskRequest -> iotd_Req . io_Length	= TRACKSIZE;
	DiskRequest -> iotd_Req . io_Data	= (APTR)Dest;
	DiskRequest -> iotd_Req . io_Offset	= Track * TRACKSIZE;

	DiskRequest -> iotd_SecLabel		= (ULONG)Dest + TRACKSIZE;

	DoIO(DiskRequest);

	return((LONG)DiskRequest -> iotd_Req . io_Error);
}

	/* ClearMem(Mem,Size):
	 *
	 *	Sets a block of memory to zero.
	 */

VOID __regargs
ClearMem(Mem,Size)
register char *Mem;
register LONG Size;
{
	while(Size-- > 0)
		*Mem++ = 0;
}

	/* ClearTrack(Track,Number):
	 *
	 *	Clears unused blocks in a disk track.
	 */

VOID __regargs
ClearTrack(Track,Number)
UBYTE *Track;
LONG Number;
{
	register LONG i;

	for(i = 0 ; i < 22 ; i++)
		if(!BlockTab[Number * 22 + i])
			ClearMem(&Track[i * TD_SECTOR],TD_SECTOR);
}

	/* CheckSum(DiskSector):
	 *
	 *	Calculates the DOS-checksum for a track.
	 */

ULONG __regargs
CheckSum(DiskSector)
ULONG *DiskSector;
{
	ULONG Sum;
	SHORT i;

	for(Sum = 0, i = 0 ; i < TD_SECTOR / 4 ; i++)
		Sum += DiskSector[i];

	return(Sum);
}

	/* GetBitmap(CompInfo):
	 *
	 *	Reads the bitmap of disk and checks if it has
	 *	a root-block.
	 */

LONG
GetBitmap(CompInfo)
struct CompInfo *CompInfo;
{
	LONG Error;
	register SHORT i;
	BYTE Answer[256];

	DiskRequest -> iotd_Req . io_Command	= TD_MOTOR;
	DiskRequest -> iotd_Req . io_Length	= 1;
	DoIO(DiskRequest);

		/* Read first sector. */

	DiskRequest -> iotd_Req . io_Command	= ETD_READ;
	DiskRequest -> iotd_Req . io_Length	= TD_SECTOR;
	DiskRequest -> iotd_Req . io_Data	= (APTR)ChipSector;
	DiskRequest -> iotd_Req . io_Offset	= 0;

	if(Error = DoIO(DiskRequest))
	{
		if(Window)
			SimpleRequest("Device error Nš %ld!\n",Error);
		else
			Printf("Device error Nš %ld!\a\n",Error);

		return(FALSE);
	}

		/* Not a standard DOS disk? */

	if((ULONG)ChipSector[0] != ID_DOS_DISK)
	{
			/* No bitmap available. */

		ClearBlocks = FALSE;

			/* Not a fast file system disk? */

		if((ULONG)ChipSector[0] != ID_FFS_DISK)
		{
				/* Ask if we are to continue. */

			if(Window)
			{
				if(!TwoGadRequest("That's  not a standard DOS disk,\ndo you want to continue?"))
					return(FALSE);
			}
			else
			{
				Printf("That's not a standard DOS disk, do you want to continue (y/N) ? ");

				Read(Input(),Answer,255);

				if(Toupper(Answer[0]) != 'Y')
					return(FALSE);
			}
		}

		return(TRUE);
	}

		/* Read the root-block. */

	DiskRequest -> iotd_Req . io_Command	= ETD_READ;
	DiskRequest -> iotd_Req . io_Length	= TD_SECTOR;
	DiskRequest -> iotd_Req . io_Data	= (APTR)ChipSector;
	DiskRequest -> iotd_Req . io_Offset	= ROOTBLOCK * TD_SECTOR;

	if(Error = DoIO(DiskRequest))
	{
		if(Window)
			SimpleRequest("Device error Nš %ld!\n",Error);
		else
			Printf("Device error Nš %ld!\a\n",Error);

		return(FALSE);
	}

		/* If checksum is zero and the block types are okay,
		 * this disk has a root-block.
		 */

	if(ChipSector[0] == 2 && ChipSector[127] == 1 && !CheckSum((ULONG *)ChipSector))
		CompInfo -> ci_ExtFlags |= CI_HASROOT;

		/* If this longword is DOSTRUE, bitmap is valid. */

	if(ChipSector[78] != DOSTRUE)
	{
		ClearBlocks = FALSE;

		if(!Window)
			Puts("\2331A\33[1m\33[33mWarning:\33[31m\33[0m Disk is not validated, unused blocks are not cleared!\n\n");

		return(TRUE);
	}

		/* Read the bitmap block. */

	DiskRequest -> iotd_Req . io_Command	= ETD_READ;
	DiskRequest -> iotd_Req . io_Length	= TD_SECTOR;
	DiskRequest -> iotd_Req . io_Data	= (APTR)ChipSector;
	DiskRequest -> iotd_Req . io_Offset	= (ChipSector[79]) * TD_SECTOR;

	if(Error = DoIO(DiskRequest))
	{
		if(Window)
			SimpleRequest("Device error Nš %ld!\n",Error);
		else
			Printf("Device error Nš %ld!\a\n",Error);

		return(FALSE);
	}

		/* Build an array of boolean values describing the
		 * state of available blocks.
		 */

	for(i = 0 ; i < 1760 ; i++)
	{
		if(ChipSector[1 + i / 32] & (1 << (i % 32)))
			BlockTab[i + 2] = FALSE;
		else
			BlockTab[i + 2] = TRUE;
	}

		/* The first two blocks are usually reserved. */

	BlockTab[0] = BlockTab[1] = TRUE;

	return(TRUE);
}

	/* MakeID(IDString):
	 *
	 *	Turns a 4 char string into a longword ID.
	 */

LONG
MakeID(IDString)
char *IDString;
{
	register LONG LongID;

	LongID = (IDString[0] << 24) | (IDString[1] << 16) | (IDString[2] << 8) | (IDString[3]);

	return(LongID);
}

	/* GetFileSize(Name):
	 *
	 *	Returns the length of a file.
	 */

LONG
GetFileSize(Name)
char *Name;
{
	struct FileInfoBlock	*FileInfo;
	BPTR			 FileLock;
	LONG			 FileSize = 0;

	if(FileInfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC))
	{
		if(FileLock = Lock(Name,ACCESS_READ))
		{
			Examine(FileLock,FileInfo);

			FileSize = FileInfo -> fib_Size;

			UnLock(FileLock);
		}

		FreeMem(FileInfo,sizeof(struct FileInfoBlock));
	}

	return(FileSize);
}

	/* WriteDump(FileName,Unit):
	 *
	 *	The main compression routine.
	 */

LONG
ReadDump(FileName,Unit)
char *FileName,*Unit;
{
	LONG				*Buffer,i,CrunchLength,Error,Success = TRUE;
	BPTR				 DumpFile;
	char				 TempString[40];
	extern struct DosLibrary	*DOSBase;
	struct DeviceNode		*DeviceNode;
	struct FileSysStartupMsg	*FileMsg;
	UBYTE				 Name[108],DevName[108];
	struct CompInfo			 CompInfo;
	unsigned short			 TrackCRC;
	struct TRStructure		 MyTextStruct;
	char				 QuestText[40];
	BOOL				 Result,HasFast;

		/* First issue: try to find the DOS-Node of the unit
		 * driver.
		 */

	strcpy(DevName,Unit);

	for(i = 0 ; i < strlen(DevName) ; i++)
	{
		if(DevName[i] == ':')
			DevName[i] = 0;
	}

		/* Some nice casting. */

	DeviceNode = (struct DeviceNode *)BADDR(((struct DosInfo *)BADDR(((struct RootNode *)DOSBase -> dl_Root) -> rn_Info)) -> di_DevInfo);

	while(DeviceNode)
	{
		B2C(Name,DeviceNode -> dn_Name);

			/* Is it the name we want? */

		if(!Strcmp(Name,DevName) && (FileMsg = (struct FileSysStartupMsg *)BADDR(DeviceNode -> dn_Startup)))
			goto FoundIt;

		DeviceNode = (struct DeviceNode *)BADDR(DeviceNode -> dn_Next);
	}

		/* Didn't find the driver. */

	if(Window)
		SimpleRequest("Couldn't find driver %s:.",DevName);
	else
		Printf("Couldn't find driver %s:.\a\n",DevName);

	return(FALSE);

		/* Go along with the driver initialization. */

FoundIt:if(!(DiskPort = (struct MsgPort *)CreatePort(NULL,0)))
	{
		if(Window)
			SimpleRequest("Couldn't create port.");
		else
			Puts("Couldn't create port.\a");

		return(FALSE);
	}

	if(!(DiskRequest = (struct IOExtTD *)CreateExtIO(DiskPort,sizeof(struct IOExtTD))))
	{
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Couldn't create device buffer.");
		else
			Puts("Couldn't create device buffer.\a");

		return(FALSE);
	}

	B2C(Name,FileMsg -> fssm_Device);

	if(OpenDevice(Name,FileMsg -> fssm_Unit,DiskRequest,0))
	{
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Couldn't open unit driver.");
		else
			Puts("Couldn't open unit driver.\a");

		return(FALSE);
	}

	if(!(ChipSector = (LONG *)AllocMem(EXTRASIZE,MEMF_CHIP | MEMF_CLEAR)))
	{
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Couldn't allocate sector buffer.");
		else
			Puts("Couldn't allocate sector buffer.\a");

		return(FALSE);
	}

	if(!(Sector = (LONG *)AllocMem(EXTRASIZE,MEMF_FAST)))
	{
		HasFast = FALSE;
		Sector = ChipSector;
	}
	else
		HasFast = TRUE;

	if(!(Buffer = (LONG *)AllocMem(EXTRASIZE,MEMF_PUBLIC | MEMF_CLEAR)))
	{
		if(HasFast)
			FreeMem(Sector,EXTRASIZE);

		FreeMem(ChipSector,EXTRASIZE);
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Couldn't allocate sector buffer.");
		else
			Puts("Couldn't allocate sector buffer.\a");

		return(FALSE);
	}

	DiskRequest -> iotd_Req . io_Command = TD_CHANGESTATE;
	DoIO(DiskRequest);

	if(DiskRequest -> iotd_Req . io_Actual)
	{
		if(HasFast)
			FreeMem(Sector,EXTRASIZE);

		FreeMem(Buffer,EXTRASIZE);
		FreeMem(ChipSector,EXTRASIZE);
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("No disk in unit.");
		else
			Puts("No disk in unit.\a");

		return(FALSE);
	}

	DiskRequest -> iotd_Req . io_Command = TD_CHANGENUM;
	DoIO(DiskRequest);

	DiskRequest -> iotd_Count = DiskRequest -> iotd_Req . io_Actual;

	if(!Inhibit(Unit,DOSTRUE))
	{
		if(HasFast)
			FreeMem(Sector,EXTRASIZE);

		FreeMem(Buffer,EXTRASIZE);
		FreeMem(ChipSector,EXTRASIZE);
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Can't inhibit unit driver.");
		else
			Puts("Can't inhibit unit driver.\a");

		return(FALSE);
	}

		/* Open the dump file. */

	if(!(DumpFile = Open(FileName,MODE_NEWFILE)))
	{
		if(HasFast)
			FreeMem(Sector,EXTRASIZE);

		Inhibit(Unit,DOSFALSE);
		FreeMem(Buffer,EXTRASIZE);
		FreeMem(ChipSector,EXTRASIZE);
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Couldn't create dump file.");
		else
			Puts("Couldn't create dump file.\a");

		return(FALSE);
	}

		/* Create the compression auxiliary buffers. */

	if(!compinit())
	{
		if(HasFast)
			FreeMem(Sector,EXTRASIZE);

		Close(DumpFile);
		Inhibit(Unit,DOSFALSE);
		FreeMem(Buffer,EXTRASIZE);
		FreeMem(ChipSector,EXTRASIZE);
		CloseDevice(DiskRequest);
		DeleteExtIO(DiskRequest);
		DeletePort(DiskPort);

		if(Window)
			SimpleRequest("Not enough memory for packer buffer.");
		else
			Puts("Not enough memory for packer buffer.\a");

		return(FALSE);
	}

		/* Initialize the dump file header. */

	CompInfo . ci_ProgramID		= MakeID(PROGRAMID);
	CompInfo . ci_Version		= PRGVERSION;
	CompInfo . ci_Compression	= 1;
	CompInfo . ci_ExtFlags		= 0;

		/* Check the bitmap. */

	if(!GetBitmap(&CompInfo))
		goto Sneak;

		/* Write the header. */

	if(Write(DumpFile,&CompInfo,sizeof(struct CompInfo)) != sizeof(struct CompInfo))
	{
		if(!Window)
			Puts("Error writing dump file.\a");
		else
			SimpleRequest("Error writing dump file.");

		Success = FALSE;

		goto Sneak;
	}

		/* Begin the compression. */

Loop:	for(i = 0 ; i < 80 ; i++)
	{
			/* Update window. */

		if(Window)
		{
			SPrintf(TempString,"%02ld/%02ld",i,79 - i);

			Move(RPort,151,76);
			Punch(TempString);

			Move(RPort,100,85);
			Punch("Read ");

			Move(RPort,151,85);
			Punch("11296");

			if(Massage = (struct IntuiMessage *)GetMsg(Window -> UserPort))
			{
				Class	= Massage -> Class;
				Gadget	= (struct Gadget *)Massage -> IAddress;

				ReplyMsg((struct Message *)Massage);

				if(Class == GADGETUP && Gadget -> GadgetID == DriveWanted)
				{
					if(TwoGadRequest("Really stop compressing from drive %s: ?",DevName))
					{
						Success = FALSE;
						goto Sneak;
					}
				}
			}
		}
		else
		{
			Printf("\2331ATrack %02ld, \233K",i);

			if(SetSignal(0,0) & SIGBREAKF_CTRL_C)
			{
				Puts("\n*** Break: CompDisk\a");
				SetSignal(0,SIGBREAKF_CTRL_C);

				Success = FALSE;

				goto Sneak;
			}
		}

			/* Read the track. */

Retry:		if(Error = DriverAction(ETD_READ,ChipSector,i))
		{
			MyTextStruct . Text		= QuestText;
			MyTextStruct . Window		= 0;
			MyTextStruct . MiddleText	= "Retry";
			MyTextStruct . PositiveText	= "Ok";
			MyTextStruct . NegativeText	= "Cancel";
			MyTextStruct . Title		= "System Request";
			MyTextStruct . KeyMask		= AMIGAKEYS;
			MyTextStruct . textcolor	= 1;
			MyTextStruct . detailcolor	= 0;
			MyTextStruct . blockcolor	= 1;
			MyTextStruct . versionnumber	= 0;
			MyTextStruct . rfu1		= 0;
			MyTextStruct . rfu2		= 0;

			SPrintf(QuestText,"Device error Nš %ld! Do you wish to continue?",Error);

			if(Window)
			{
				Result = TextRequest(&MyTextStruct);

				switch(Result)
				{
						/* Ignore. */

					case 2:	goto GoOn;

						/* Retry. */

					case 1:	goto Retry;

						/* Cancel. */

					case 0:	Success = FALSE;
						goto Sneak;
				}
			}
			else
			{
				Printf("Device error Nš %ld! Do you wish to continue ([r]etry/[i]gnore/[C]ancel) ? \a",Error);

				Read(Input(),QuestText,39);

				switch(Toupper(QuestText[0]))
				{
						/* Ignore. */

					case 'I':	goto GoOn;

						/* Retry. */

					case 'R':	goto Retry;

						/* Cancel */

					default:	Success = FALSE;
							goto Sneak;
				}
			}
		}

GoOn:		if(Window)
		{
			Move(RPort,100,85);
			Punch("Check");
		}
		else
			Printf("checking, ");

			/* Push the block over... */

		if(HasFast)
			CopyMemQuick(ChipSector,Sector,EXTRASIZE);

			/* Clear unused blocks if necessary. */

		if(ClearBlocks)
			ClearTrack((UBYTE *)Sector,i);

			/* Calculate the CRC value for this track. */

		TrackCRC = DoBlockCrc((UBYTE *)Sector,EXTRASIZE);

		if(!Window)
			Printf("packing... ");
		else
		{
			Move(RPort,100,85);
			Punch("Pack ");
		}
			
			/* Compress the track. */

		CrunchLength = compfiles((char *)Sector,EXTRASIZE,(char *)Buffer,EXTRASIZE);

		if(!Window)
			Printf("%ld, ",CrunchLength);

			/* Not a good result, we'll store the data as is. */

		if(CrunchLength < 1 || CrunchLength >= EXTRASIZE)
			CrunchLength = 0;

		if(Window)
		{
			Move(RPort,100,85);
			Punch("Write ");

			Move(RPort,151,85);

			SPrintf(TempString,"%5ld",(CrunchLength) ? CrunchLength : 11264);
			Punch(TempString);
		}
		else
			Printf("writing...\n");

			/* Write the length of the track. */

		if(Write(DumpFile,&CrunchLength,sizeof(LONG)) != sizeof(LONG))
		{
			if(!Window)
				Puts("Error writing dump file.\a");
			else
				SimpleRequest("Error writing dump file.");

			Success = FALSE;

			break;
		}

			/* Write the CRC value. */

		if(Write(DumpFile,&TrackCRC,sizeof(unsigned short)) != sizeof(unsigned short))
		{
			if(!Window)
				Puts("Error writing dump file.\a");
			else
				SimpleRequest("Error writing dump file.");

			Success = FALSE;

			break;
		}

			/* Write the compressed data if necessary. */

		if(CrunchLength)
		{
			if(Write(DumpFile,Buffer,CrunchLength) != CrunchLength)
			{
				if(!Window)
					Puts("Error writing dump file.\a");
				else
					SimpleRequest("Error writing dump file.");

				Success = FALSE;

				break;
			}
		}
		else
		{
				/* Write the data as is. */

			if(Write(DumpFile,Sector,EXTRASIZE) != EXTRASIZE)
			{
				if(!Window)
					Puts("Error writing dump file.\a");
				else
					SimpleRequest("Error writing dump file.");

				Success = FALSE;
				break;
			}
		}
	}

		/* Close the file. */

Sneak:	Close(DumpFile);

		/* Turn the motor off. */

	DiskRequest -> iotd_Req . io_Command	= TD_MOTOR;
	DiskRequest -> iotd_Req . io_Length	= 0;

	DoIO(DiskRequest);

		/* Free the resources. */

	CloseDevice(DiskRequest);
	DeleteExtIO(DiskRequest);
	DeletePort(DiskPort);

	FreeMem(Buffer,EXTRASIZE);
	FreeMem(ChipSector,EXTRASIZE);

	if(HasFast)
		FreeMem(Sector,EXTRASIZE);

	Inhibit(Unit,DOSFALSE);

	compexit();

	return(Success);
}

	/* FindDevice(DevName):
	 *
	 *	Tries to find a device, returns true if successful.
	 */

LONG
FindDevice(DevName)
char *DevName;
{
	char				*Pointer,Name[257];
	extern struct DosLibrary	*DOSBase;
	register struct DeviceNode	*DevInfo;
	struct RootNode			*RootNode = (struct RootNode *)DOSBase -> dl_Root;
	SHORT				 i;

	Forbid();

	DevInfo = (struct DeviceNode *)BADDR(((struct DosInfo *)BADDR(RootNode -> rn_Info)) -> di_DevInfo);

	while(DevInfo)
	{
		if(DevInfo -> dn_Type == DLT_DEVICE && DevInfo -> dn_Task)
		{
			Pointer = (char *)BADDR(DevInfo -> dn_Name);

			for(i = 0 ; i < Pointer[0] ; i++)
				Name[i] = Pointer[i + 1];

			Name[Pointer[0]    ] = ':';
			Name[Pointer[0] + 1] = 0;

			if(!Strcmp(Name,DevName))
			{
				Permit();
				return(TRUE);
			}
		}

		DevInfo = (struct DeviceNode *)BADDR(DevInfo -> dn_Next);
	}

	Permit();

	return(FALSE);
}

	/* EraseGadget(RPort,Gadget,Colour):
	 *
	 *	Erase the imagery of a gadget.
	 */

VOID
EraseGadget(RPort,Gadget,Colour)
struct RastPort *RPort;
struct Gadget *Gadget;
LONG Colour;
{
	SetAPen(RPort,Colour);

	SetDrMd(RPort,JAM2);

	RectFill(RPort,Gadget -> LeftEdge,Gadget -> TopEdge,Gadget -> LeftEdge + Gadget -> Width - 1,Gadget -> TopEdge + Gadget -> Height - 1);

	SetAPen(RPort,1);
}

	/* GetChangeCount(Drive):
	 *
	 *	Get the disk change count for a drive (the ETD_... commands
	 *	need it.
	 */

LONG
GetChangeCount(Drive)
LONG Drive;
{
	LONG Count = -1;

	if(DiskPort = (struct MsgPort *)CreatePort(NULL,0))
	{
		if(DiskRequest = (struct IOExtTD *)CreateExtIO(DiskPort,sizeof(struct IOExtTD)))
		{
			if(!OpenDevice("trackdisk.device",Drive,DiskRequest,0))
			{
				DiskRequest -> iotd_Req . io_Command = TD_CHANGENUM;
				DoIO(DiskRequest);

				Count = DiskRequest -> iotd_Req . io_Actual;

				CloseDevice(DiskRequest);
			}

			DeleteExtIO(DiskRequest);
		}

		DeletePort(DiskPort);
	}

	DiskRequest = NULL;
	DiskPort = NULL;

	return(Count);
}

	/* Stub, don't need this one. */

LONG CXBRK() { return(0); }

	/* main(argc,argv):
	 *
	 *	The entry point to this program.
	 */

VOID __stdargs
main(argc,argv)
LONG argc;
char **argv;
{
	struct Process	*ThatsMe = (struct Process *)SysBase -> ThisTask;
	LONG		 i,Waiting = FALSE,Who;
	ULONG		 Secs1,Secs2,Micros;
	APTR		 OldPtr;

		/* Started from Workbench? */

	if(ThatsMe -> pr_CLI)
		goto CallOn;

		/* Open the req.library. */

	if(!(ReqBase = (struct Library *)OpenLibrary("req.library",0)))
		exit(RETURN_FAIL);

		/* Don't forget the standard font. */

	if(!(TextFont = (struct TextFont *)OpenFont(&TxtAttr)))
	{
		CloseLibrary(ReqBase);
		exit(RETURN_FAIL);
	}

		/* All device gadgets are vacant. */

	for(i = 0 ; i < 5 ; i++)
		Legal[i] = TRUE;

		/* Try to open it, if it doesn't open don't squeak about it. */

	IconBase = OpenLibrary("icon.library",0);

	SPrintf(WindowName,"CompDisk 1.%ld  ",PRGVERSION);

		/* Now try to find if there's a legal drive for each
		 * gadget.
		 */

	if(!FindDevice("RAD:"))
	{
		BoxGad[0] . Flags |= GADGDISABLED;
		Legal[0] = FALSE;
	}

	if(!FindDevice("DF3:"))
	{
		BoxGad[1] . Flags |= GADGDISABLED;
		Legal[1] = FALSE;
	}

	if(!FindDevice("DF2:"))
	{
		BoxGad[2] . Flags |= GADGDISABLED;
		Legal[2] = FALSE;
	}

	if(!FindDevice("DF1:"))
	{
		BoxGad[3] . Flags |= GADGDISABLED;
		Legal[3] = FALSE;
	}

	if(!FindDevice("DF0:"))
	{
		BoxGad[4] . Flags |= GADGDISABLED;
		Legal[4] = FALSE;
	}

		/* So we have valid destination path. */

	PathName(ThatsMe -> pr_CurrentDir,StrInfStr,DSIZE * 3);

		/* Remember old AmigaDOS requester ptr. */

	OldPtr = ThatsMe -> pr_WindowPtr;

	for(i = 0 ; i < 4 ; i++)
		ChangeCount[i] = GetChangeCount(i);

		/* Centre the window under the mouse. */

	Center(&NewWindow,NewWindow . Width / 2,NewWindow . Height / 2);

		/* Open the window. */

	if(Window = OpenWindow(&NewWindow))
	{
		LONG	 TempLock,TempVal;
		UBYTE	*RemText,*RemMain;

		ThatsMe -> pr_WindowPtr = (APTR)Window;

		RPort = Window -> RPort;

		SetFont(RPort,TextFont);

		SetAPen(RPort,1);

		FOREVER
		{
			Move(RPort,100,76);
			Punch("Track");

			Move(RPort,151,76);
			Punch("00/00");

			Move(RPort,100,85);
			Punch("Idle ");

			Move(RPort,151,85);
			Punch("    0");

			WaitPort(Window -> UserPort);

			if(Massage = (struct IntuiMessage *)GetMsg(Window -> UserPort))
			{
				Class	= Massage -> Class;
				Code	= Massage -> Code;
				Gadget	= (struct Gadget *)Massage -> IAddress;

				ReplyMsg((struct Message *)Massage);

					/* Close the window? */

				if(Class == CLOSEWINDOW)
					break;

				if(Class == GADGETUP)
				{
						/* User entered a path name. */

					if(Gadget -> GadgetID == 5)
					{
						if(!strlen(StrInfStr))
						{
Build:							PathName(ThatsMe -> pr_CurrentDir,StrInfStr,DSIZE * 3);
							RefreshGadgets(&BoxGad[0],Window,NULL);
						}

						if(!(TempLock = Lock(StrInfStr,ACCESS_READ)))
						{
							DisplayBeep(Window -> WScreen);

							SimpleRequest("Can't get a lock on directory\n\"%s\"!",StrInfStr);
							goto Build;
						}
						else
							UnLock(TempLock);

						continue;
					}

					if(Waiting)
						goto Finish;

						/* Select/deselect a drive gadget. */

					TempVal = Gadget -> GadgetID;

					RemText = BoxIntTxt[TempVal] . IText;

					BoxIntTxt[TempVal] . IText = (UBYTE *)"Stop!";

					EraseGadget(RPort,&BoxGad[TempVal],3);

					for(i = 0 ; i < 5 ; i++)
						if(i != TempVal && Legal[i])
							OffGadget(&BoxGad[i],Window,NULL);

					RefreshGadgets(&BoxGad[0],Window,NULL);

					RemMain = BoxIntTxt[5] . IText;

					if(TempVal == 0)
						goto DoIt;

					BoxIntTxt[5] . IText = (UBYTE *)"Insert Disk";

					RefreshGadgets(&BoxGad[0],Window,NULL);

					DriveWanted = TempVal;

					Waiting = TRUE;
					continue;

Finish:					for(i = 0 ; i < 5 ; i++)
					{
						if(i != TempVal && Legal[i])
						{
							EraseGadget(RPort,&BoxGad[i],0);
							OnGadget(&BoxGad[i],Window,NULL);
						}
					}

					BoxIntTxt[TempVal] . IText = RemText;

					BoxIntTxt[5] . IText = RemMain;

					EraseGadget(RPort,&BoxGad[TempVal],0);

					RefreshGadgets(&BoxGad[0],Window,NULL);

					Waiting = FALSE;

					DriveWanted = -1;
				}

					/* Inserted a disk. */
		
				if(Class == DISKINSERTED)
				{
					if(DriveWanted == -1)
						continue;

					Who = -1;

					for(i = 0 ; i < 4 ; i++)
					{
						if(ChangeCount[i] != GetChangeCount(i) && i == (4 - DriveWanted))
							Who = i;

						ChangeCount[i] = GetChangeCount(i);
					}

					if(Who == -1)
						continue;

						/* Is it the drive we want? */

DoIt:					for(i = strlen(StrInfStr) - 1 ; i >= 0 ; i--)
					{
						if(StrInfStr[i] != ':')
							StrInfStr[i] = 0;
						else
							break;
					}

					if(TempLock = Lock(Drives[DriveWanted],ACCESS_READ))
					{
						struct FileInfoBlock *FileInfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC);

						if(Examine(TempLock,FileInfo))
						{
							TackOn(StrInfStr,FileInfo -> fib_FileName);
							strcat(StrInfStr,".CMP");
							RefreshGadgets(&BoxGad[0],Window,NULL);
						}
						else
						{
							TackOn(StrInfStr,"NoName");
							strcat(StrInfStr,".CMP");
							RefreshGadgets(&BoxGad[0],Window,NULL);
						}

						UnLock(TempLock);
						FreeMem(FileInfo,sizeof(struct FileInfoBlock));
					}
					else
					{
						DisplayBeep(NULL);
						continue;
					}

					BoxIntTxt[5] . IText = (UBYTE *)"   Working ";

					RefreshGadgets(&BoxGad[0],Window,NULL);

					SetDrMd(RPort,JAM2);

					RemoveGadget(Window,&BoxGad[5]);

					SetWait(Window);

						/* Create the dump file. */

					if(!ReadDump(StrInfStr,Drives[DriveWanted]))
					{
						DeleteFile(StrInfStr);
						DisplayBeep(NULL);
					}
					else
					{
							/* If possible, create the icon. */

						if(IconBase)
							SaveProjectIcon(StrInfStr);

							/* Ring the bell. */

						Announce();

						SimpleRequest("Resulting dump file \"%s\" is %ld\nbytes long.",StrInfStr,GetFileSize(StrInfStr));
					}

					for(i = strlen(StrInfStr) - 1 ; i >= 0 ; i--)
					{
						if(StrInfStr[i] != ':')
							StrInfStr[i] = 0;
						else
							break;
					}

					AddGadget(Window,&BoxGad[5],5);

					BoxIntTxt[5] . IText = (UBYTE *)"Insert Disk";

					RefreshGadgets(&BoxGad[0],Window,NULL);

						/* Finished, wait for next disk. */

					ClearPointer(Window);
				}
			}
		}

		CloseWindow(Window);
	}
	else
		SimpleRequest("Couldn't open Window!");

		/* Restore the old ptr. */

	ThatsMe -> pr_WindowPtr = OldPtr;

		/* Close the rest. */

	if(IconBase)
		CloseLibrary(IconBase);

	CloseFont(TextFont);

	CloseLibrary(ReqBase);

	exit(RETURN_OK);

		/* This follows the CLI interface. */

CallOn:	if(!argv[ARG_FILE])
	{
		Puts("\33[1mCompDisk:\33[0m Output/source filename required.");
		Puts(CLI_Help);
		exit(RETURN_WARN);
	}

		/* Drive name given? */

	if(!argv[ARG_DRIVE])
	{
		Puts("\33[1mCompDisk:\33[0m Output/source drive name required.");
		Puts(CLI_Help);
		exit(RETURN_WARN);
	}

	if(argv[ARG_NOCLEAR])
	{
		ClearBlocks = FALSE;
		Puts("\33[1m\33[33mWarning:\33[31m\33[0m unused blocks are \33[4mnot\33[0m cleared!");
	}

	Puts("");

		/* So we have valid time counter. */

	CurrentTime(&Secs1,&Micros);

		/* Do the compression. */

	if(!ReadDump(argv[ARG_FILE],argv[ARG_DRIVE]))
	{
		DeleteFile(argv[ARG_FILE]);
		Printf("\nDestination file \"%s\" removed.\n",argv[ARG_FILE]);
	}
	else
		Printf("\2331AResulting dump file \"%s\" is %ld bytes long.\233K\n",argv[ARG_FILE],GetFileSize(argv[ARG_FILE]));

		/* Compare the difference. */

	CurrentTime(&Secs2,&Micros);

		/* Show the statistics. */

	Printf("Elapsed time = %ld.%02ld minutes\n",(Secs2 - Secs1) / 60,(Secs2 - Secs1) % 60);

	exit(RETURN_OK);
}