opt	l+,o+,ow-,ow6+
		output	Source:EditKeys.o

		; EditKeys v1.2
		; © 1991 by David Kinder

		; EditKeys.s - Main source code

		; Assemble with Devpac v3 then link:
		; 1> Blink EditKeys.o Graphics.o TO EditKeys

		; The header "system.gs" must have been compiled
		; from v36 or higher include files.

		; "I guess I believed in what we had
		;  But words got in the way"
		;	The Sisters of Mercy

		include	Source:xref.i

		incdir	Source:include/
		include	devices/keymap.i
		include	dos/rdargs.i
		include	libraries/asl.i
		include libraries/asl_lib.i
		include	libraries/arp_lib.i
		include	workbench/wb_lib.i

CALLSYS		MACRO
		jsr	_LVO\1(a6)
		ENDM

		section	Code,code

		movem.l	d0/a0,Parms		; Save parameters

		suba.l	a1,a1
		CALLEXEC FindTask
		move.l	d0,a4

		tst.l	pr_CLI(a4)		; Are we CLI or Workbench?
		bne.s	EndStartup

		lea	pr_MsgPort(a4),a0
		CALLSYS	WaitPort		; Wait for a message
		lea	pr_MsgPort(a4),a0
		CALLSYS	GetMsg			; Then get it
		move.l	d0,ReturnMsg

EndStartup	bsr.s	_Main
		tst.l	ReturnMsg
		beq.s	ExitToDOS

		CALLEXEC Forbid
		move.l	ReturnMsg,a1
		CALLSYS	ReplyMsg

ExitToDOS	move.l	d5,d0
		rts

_Main		lea	IntName,a1		; Are we running under
		moveq	#36,d0			; KickStart 2?
		CALLEXEC OpenLibrary
		move.l	d0,_IntuitionBase
		beq	NoNewOS

		move.b	#1,OS2			; Note version
		move.b	#1,MyBord1+bd_FrontPen
		move.b	#1,MyBord2+bd_FrontPen
		move.b	#1,MyBord3+bd_FrontPen
		move.b	#3,MoreText+it_FrontPen
		move.b	#0,NewName+it_FrontPen
		move.b	#0,OpenName+it_FrontPen
		move.b	#0,SaveName+it_FrontPen
		move.b	#0,SaveAsName+it_FrontPen
		move.b	#0,AboutName+it_FrontPen
		move.b	#0,IconifyName+it_FrontPen
		move.b	#0,QuitName+it_FrontPen
		addi	#11,MainWindow+nw_TopEdge
		move.l	#x2_Imagea,Gadg0a+gg_GadgetRender
		move.l	#x2_Imageb,Gadg0b+gg_GadgetRender
		move.l	#x2_Imagec,Gadg0c+gg_GadgetRender
		move.l	#x2_Imaged,Gadg0d+gg_GadgetRender
		move.l	#x2_Imagee,Gadg0e+gg_GadgetRender
		move.l	#x2_CSI,CSIGadg+gg_GadgetRender
		move.l	#0,MyBord3+bd_NextBorder
		move.b	#2,DoubleReq+rq_BackFill
		move.b	#1,DblBord1+bd_FrontPen
		move.b	#1,DblBord2+bd_FrontPen
		move.b	#1,DblBord3+bd_FrontPen
		move.b	#1,DblBord4+bd_FrontPen
		move.b	#2,DblGText4+it_BackPen
		move.b	#1,DblGBord1+bd_FrontPen
		move.b	#1,DblGBord2+bd_FrontPen
		move.b	#1,DblGBord3+bd_FrontPen
		move.b	#1,DblGBord4+bd_FrontPen
		move.b	#2,LoseReq+rq_BackFill
		move.b	#1,LsBord1+bd_FrontPen
		move.b	#1,LsBord2+bd_FrontPen
		move.b	#1,LsGBord1+bd_FrontPen
		move.b	#1,LsGBord2+bd_FrontPen
		move.l	#x2_Ls,LsGadg1+gg_GadgetRender
		move.l	#x2_Comp,LsGadg4+gg_GadgetRender
		move.b	#10,Par_Modify

		lea	Gadg0a,a0
		bsr	FixGadg
		lea	Gadg0b,a0
		bsr	FixGadg
		lea	Gadg0c,a0
		bsr	FixGadg
		lea	Gadg0d,a0
		bsr.s	FixGadg
		lea	Gadg0e,a0
		bsr.s	FixGadg
		lea	CSIGadg,a0
		bsr.s	FixGadg

		lea	Img01dt,a0
.colours	eori	#$ffff,(a0)+
		cmpa.l	#CSIdat,a0
		bne	.colours

		moveq	#0,d0			; Try to open the
		lea	AslLibName,a1		; asl.library
		CALLEXEC OpenLibrary
		move.l	d0,_AslBase
		beq	NoArp
		movea.l	_AslBase,a6
		CALLSYS	AllocFileRequest	; Get struct
		move.l	d0,AslFReq
		beq	NoArp
		move.l	d0,a0
		move.l	rf_Dir(a0),xDir
		move.l	rf_File(a0),xFile

		lea	DosName,a1		; Open 'dos.library'
		moveq	#36,d0
		CALLEXEC OpenLibrary
		move.l	d0,_DOSBase
		beq	NoArp
		bra.s	RunAllOS

FixGadg		subi	#2,gg_LeftEdge(a0)
		subi	#1,gg_TopEdge(a0)
		addi	#4,gg_Width(a0)
		addi	#2,gg_Height(a0)
		rts

NoNewOS		lea	IntName,a1		; Open 'intuition.library'
		moveq	#33,d0			; Need v1.2 or later
		CALLEXEC OpenLibrary
		move.l	d0,_IntuitionBase
		beq	NoIntuition		; Open failed

		lea	ArpName,a1		; Open 'arp.library'
		moveq	#0,d0
		CALLSYS	OpenLibrary
		move.l	d0,_DOSBase
		beq	NoArpLib

RunAllOS	lea	GrafName,a1		; Open 'graphics.library'
		moveq	#0,d0
		CALLEXEC OpenLibrary
		move.l	d0,_GfxBase
		beq	NoGraphics		; Open failed

		movem.l	Parms,d0/a0		; Analyse parameters
		tst.l	ReturnMsg
		beq.s	ChanceParms

		move.l	ReturnMsg,a0		; Get correct
		move.l	sm_ArgList(a0),a0	; 'current directory'
		move.l	wa_Lock(a0),d1		; for Workbench
		CALLDOS	CurrentDir
		bra	NoChanceParms

ChanceParms	bsr	_GADS			; Parse input line
		tst.l	d7
		bmi.s	LineError
		tst.l	Par_Arry+4		; Was it 'NOMAP'?
		bne.s	SetNone
		tst.l	d7
		beq.s	NoChanceParms
		bra.s	CParms

SetNone		move	#HIGHCOMP!ITEMTEXT!COMMSEQ,Save+mi_Flags
		bra	IconReturn		; Disable 'Save' menu item

CParms		move.l	Par_Arry,a0
		lea	PathName,a1
		movea.l	xFile,a2
		moveq	#0,d0
		moveq	#13,d5
CParmsLp	move.b	(a0,d0),(a1,d5)
		move.b	(a0,d0),(a2,d0)
		beq.s	AllLoad
		addq	#1,d0
		addq	#1,d5
		cmpi.b	#72,d5
		beq.s	AllLoad
		bra	CParmsLp

LineError	tst.b	OS2
		bne.s	.line
		move.l	Par_Arry,a1
		CALLDOS	Puts
		bra	NoRun
.line		neg.l	d7
		move.l	d7,d1
		moveq	#0,d2
		CALLDOS	PrintFault
		bra	NoRun

NoChanceParms	move.b	#1,ErrResponse
		movea.l	AslFReq,a0		; Can we use ASL?
		cmpa.l	#0,a0
		beq.s	PUseArp
		lea	LoadTags,a1
		movea.l	_AslBase,a6
		CALLSYS	AslRequest
		bra.s	PAllFDo
PUseArp		lea	ArpFileReq,a0
		CALLDOS	FileRequest		; Call ARP FileRequest()

PAllFDo		tst.l	d0
		beq	SetNone
		bsr	ARP_Extract		; Get path
AllLoad		bsr	LoadKeyMap
		cmpi	#1,d6
		beq	NoRun
		tst	d6
		beq.s	ItWentOK
		move.l	MySegment,d1
		CALLDOS	UnLoadSeg
		bra	NoRun

ItWentOK	bsr	CopyToSave
		bsr	AnalyseKM
		bsr	GenerateKeys
		bsr	CancelDead

IconReturn	move.b	#2,ErrResponse
		lea	MainWindow,a0		; Open our window on
		CALLINT	OpenWindow		; Workbench screen
		move.l	d0,Windowhd
		beq	NoRun		; Open window failed
		bsr	WindSetUp

		move.l	Windowhd,a0		; Install menus
		lea	ProjectMenu,a1
		CALLSYS	SetMenuStrip
		tst.l	d0
		beq	NoMenus			; Menus failed

		move.l	RPort,a1		; Set up colours for...
		moveq	#1,d0
		tst.b	OS2
		beq.s	UsePen1
		moveq	#2,d0
UsePen1		CALLGRAF SetAPen

		move.l	RPort,a1		; ...an area fill for
		moveq	#4,d0			; a 'keyboard' look!
		moveq	#11,d1
		move	#587,d2
		moveq	#89,d3
		CALLSYS	RectFill

		tst.b	OS2
		beq.s	DoOSGadg
		move.l	RPort,a0
		lea	x2_Box,a1
		moveq	#91,d0
		moveq	#110,d1
		CALLINT	DrawImage

DoOSGadg	move.l	Windowhd,a0		; We don't want to have
		lea	Gadg0a,a1		; intuition draw all the
		moveq	#0,d0			; gadgets, then draw over
		moveq	#-1,d1			; them, then redraw them,
		suba.l	a2,a2			; so we only add the gadgets
		CALLINT	AddGList		; here

		lea	Gadg0a,a0		; This makes the gadgets
		move.l	Windowhd,a1		; visible over the white
		suba.l	a2,a2			; background
		CALLSYS	RefreshGadgets

		move.l	RPort,a0		; Add a few finishing
		lea	MyBord1,a1		; extras to the display...
		moveq	#0,d0
		moveq	#0,d1
		CALLSYS	DrawBorder

		move.l	RPort,a0
		lea	MoreText,a1
		moveq	#0,d0
		moveq	#0,d1
		CALLSYS	PrintIText

		move.l	RPort,a0
		lea	MoreText,a1
		move	#256,d0
		moveq	#0,d1
		CALLSYS	PrintIText

		move.l	RPort,a0
		lea	SqrText,a1
		moveq	#0,d0
		moveq	#0,d1
		CALLSYS	PrintIText

		cmpi.b	#1,MyMode		; Should we enable
		bne.s	MainLoop		; DMRequest()?
		move.l	Windowhd,a0
		lea	DoubleReq,a1
		CALLSYS	SetDMRequest

MainLoop	move.l	UserPort,a0		; Wait for an Intuition
		CALLEXEC WaitPort		; message...
CheckMessage	move.l	UserPort,a0
		CALLEXEC GetMsg
		tst.l	d0
		beq	MainLoop
		move.l	d0,a1
		move.l	im_Class(a1),d2		; Store the message
		move	im_Code(a1),d3
		move	im_Qualifier(a1),d4
		move.l	im_IAddress(a1),a2
		CALLSYS	ReplyMsg
		cmpi.l	#CLOSEWINDOW,d2		; Is it close time?
		beq	QuitProper
		cmpi.l	#MENUPICK,d2
		beq.s	GoMenu
		cmpi.l	#GADGETDOWN,d2
		beq	GoGadget
		cmpi.l	#GADGETUP,d2
		beq	KeyGadget
		cmpi.l	#RAWKEY,d2
		beq.s	KeyPress
		cmpi.l	#REQSET,d2
		beq	ReqStart
		bra	CheckMessage

KeyPress	cmpi	#$5f,d3			; Was it 'Help'?
		bne	CheckMessage

		move.l	Windowhd,a0		; If so, set up a help
		lea	HlpText1,a1		; requester
		suba.l	a2,a2
		lea	ContText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#520,d2
		moveq	#71,d3
		CALLINT	AutoRequest
		bra	CheckMessage

GoMenu		move.l	d3,d0
		andi.l	#%0000000000011111,d0	; Was it the project menu?
		bne	CheckMessage
		
		move.l	d3,d0			; Check the subitems
		andi.l	#%0000011111100000,d0
		beq.s	MNew
		cmpi.l	#%0000000000100000,d0
		beq	MOpen
		cmpi.l	#%0000000001000000,d0
		beq	MSave
		cmpi.l	#%0000000001100000,d0
		beq	MSaveAs
		cmpi.l	#%0000000010100000,d0
		beq	MIconify
		cmpi.l	#%0000000011000000,d0
		beq	QuitProper
		bra	CheckMessage

MNew		move.l	Windowhd,a0		; Are you sure?
		lea	MNewText,a1
		lea	LReqText,a2
		lea	RReqText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#407,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		tst.l	d0
		beq	CheckMessage

		bsr	ClearOut
		bsr	GenerateKeys
		move.l	Windowhd,a0		; Disable 'Save' item...
		move.l	#%0000000001000000,d0
		CALLINT	OffMenu
		move	#"«»",ModWindText-1	; ...and reset name
		clr.b	ModWindText+1
		move.l	Windowhd,a0
		lea	MainWindowText,a1
		move.l	#-1,a2
		CALLSYS	SetWindowTitles
		move.l	#$20202020,DeadTxt
		move.l	#$20202000,DeadTxt+4
		move.l	#$20202020,DblGTxt4
		move.l	#$20202000,DblGTxt4+4
		clr.b	CurrDKey
		move.b	#1,ChQVal
		bsr	ChangeKString
		clr.b	ChQVal
MNew_NK		move.b	MyMode,d0
		cmpi.b	#1,d0
		beq	GGadga
		cmpi.b	#2,d0
		beq	GGadgb
		cmpi.b	#3,d0
		beq	GGadgc
		cmpi.b	#4,d0
		beq	GGadgd
		bra	GGadge

MIconify	move.l	Windowhd,a0		; Close old window...
		move	wd_LeftEdge(a0),IconWindow
		move	wd_TopEdge(a0),IconWindow+2
		CALLINT	ClearMenuStrip
		move.l	Windowhd,a0
		CALLSYS	ClearDMRequest
		move.l	Windowhd,a0
		CALLSYS	CloseWindow

		tst.b	OS2
		beq	DoOldIcon
		lea	WBName,a1		; If we are running
		moveq	#36,d0			; under 2.0, its nicer
		CALLEXEC OpenLibrary		; to become a menu item
		move.l	d0,_WorkbenchBase	; than a small window
		beq.s	NoWBLib
		CALLSYS	CreateMsgPort
		move.l	d0,MyWBPort
		beq.s	NoPort

		moveq	#1,d0
		moveq	#1,d1
		lea	WBTxt,a0
		move.l	MyWBPort,a1
		suba.l	a2,a2
		movea.l	_WorkbenchBase,a6
		CALLSYS	AddAppMenuItemA
		move.l	d0,d7

		movea.l	MyWBPort,a0		; Wait for what must be
		CALLEXEC WaitPort		; an AppMessage
CheckWBMsg	move.l	MyWBPort,a0
		CALLSYS	GetMsg
		tst.l	d0
		beq.s	ShutWB
		move.l	d0,a1
		CALLSYS	ReplyMsg
		bra	CheckWBMsg

ShutWB		move.l	d7,a0
		movea.l	_WorkbenchBase,a6
		CALLSYS	RemoveAppMenuItem
		movea.l	MyWBPort,a0
		CALLEXEC DeleteMsgPort
NoPort		movea.l	_WorkbenchBase,a1
		CALLEXEC CloseLibrary
NoWBLib		bra	IconReturn

DoOldIcon	lea	IconWindow,a0
		CALLSYS	OpenWindow
		move.l	d0,Windowhd
		beq	NoRun
		bsr	WindSetUp

IconLoop	move.l	UserPort,a0
		CALLEXEC WaitPort
		move.l	UserPort,a0
		CALLSYS	GetMsg
		tst.l	d0
		beq	IconLoop
		move.l	d0,a1
		move.l	im_Class(a1),d2
		CALLSYS	ReplyMsg
		cmpi.l	#GADGETUP,d2
		bne	IconLoop

		move.l	Windowhd,a0		; Close iconified window
		CALLINT	CloseWindow
		bra	IconReturn

MOpen		movea.l	AslFReq,a0		; Can we use ASL?
		cmpa.l	#0,a0
		beq.s	OUseArp
		lea	LoadTags,a1
		movea.l	_AslBase,a6
		CALLSYS	AslRequest
		bra.s	OAllFDo
OUseArp		move.l	#fr_LHail,ArpFileReq
		lea	ArpFileReq,a0
		CALLDOS	FileRequest		; Call ARP FileRequest()

OAllFDo		tst.l	d0
		beq	CheckMessage
		bsr	ARP_Extract		; Analyse response
		bsr	LoadKeyMap
		cmpi	#1,d6
		beq	NotFoundErr
		tst	d6
		beq.s	NewOkay
		move.l	MySegment,d1
		CALLDOS	UnLoadSeg
		move.l	Windowhd,a0
		lea	OpenErr2,a1
		suba.l	a2,a2
		lea	ContText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#342,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	CheckMessage

NewOkay		bsr	CopyToSave
		bsr	AnalyseKM
		bsr	GenerateKeys
		move.l	Windowhd,a0
		lea	MainWindowText,a1
		move.l	#-1,a2
		CALLINT	SetWindowTitles
		move.l	#$20202020,DeadTxt
		move.l	#$20202000,DeadTxt+4
		move.l	#$20202020,DblGTxt4
		move.l	#$20202000,DblGTxt4+4
		clr.b	CurrDKey
		move.b	#1,ChQVal
		bsr	ChangeKString
		clr.b	ChQVal
		move.b	MyMode,d0
		cmpi.b	#1,d0
		beq	GGadga
		cmpi.b	#2,d0
		beq	GGadgb
		cmpi.b	#3,d0
		beq	GGadgc
		cmpi.b	#4,d0
		beq	GGadgd
		bra	GGadge

NotFoundErr	move.l	Windowhd,a0
		lea	OpenErr1,a1
		suba.l	a2,a2
		lea	ContText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#350,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	CheckMessage

MSave		move.l	#10240,d0
		move.l	#MEMF_CLEAR,d1
		CALLEXEC AllocMem		; Get a buffer
		movea.l	d0,a5			; a5 is index into
		move.l	d0,SaveBuffer		; SaveBuffer
		beq	NoMemBuff

		move.l	#5120,d0
		move.l	#MEMF_CLEAR,d1
		CALLSYS	AllocMem
		move.l	d0,SaveBuffer2
		bne.s	GotAllMem

		movea.l	SaveBuffer,a1		; Free buffer
		move.l	#10240,d0
		CALLSYS	FreeMem
		bra	NoMemBuff

GotAllMem	bsr	CreateOutput		; Fill buffer...

		move.l	#SavePath,d1
		move.l	#MODE_NEWFILE,d2
		CALLDOS	Open			; Open output file
		move.l	d0,d7			; Get file handle
		beq	NoOpenMap

		move.l	d7,d1
		move.l	SaveBuffer,d2
		move.l	a5,d3
		sub.l	SaveBuffer,d3
		CALLSYS	Write			; Write keymap
		move.l	d7,d1
		CALLSYS	Close			; Close keymap

		movea.l	xFile,a0		; Get keymap name
		lea	ModWindText,a1
.loop		move.b	(a0)+,d1
		beq.s	.end
		move.b	d1,(a1)+
		cmpa.l	#EndWindText,a1
		beq.s	.end
		bra	.loop

.end		move.b	#"»",(a1)+
		clr.b	(a1)
		movea.l	Windowhd,a0
		lea	MainWindowText,a1
		movea.l	#-1,a2
		CALLINT	SetWindowTitles

SaveEnd		movea.l	SaveBuffer,a1		; Free buffer
		move.l	#10240,d0
		CALLEXEC FreeMem
		movea.l	SaveBuffer2,a1
		move.l	#5120,d0
		CALLSYS	FreeMem
		bra	CheckMessage

NoMemBuff	move.l	Windowhd,a0		; Not enough memory so
		lea	NSavText,a1		; flag then return without
		suba.l	a2,a2			; saving keymap
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#311,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	CheckMessage

NoOpenMap	move.l	Windowhd,a0
		lea	OpenSErr,a1
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#278,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	SaveEnd

MSaveAs		movea.l	AslFReq,a0		; Can we use ASL?
		cmpa.l	#0,a0
		beq.s	SUseArp
		lea	SaveTags,a1
		movea.l	_AslBase,a6
		CALLSYS	AslRequest
		bra.s	SAllFDo
SUseArp		move.l	#fr_SHail,ArpFileReq
		lea	ArpFileReq,a0
		CALLDOS	FileRequest		; Call ARP FileRequest()

SAllFDo		tst.l	d0
		beq	CheckMessage
		bsr	ARP_Extract		; Analyse response
		bsr	CopyToSave
		bra	MSave

CreateOutput	move.l	#$3f3,(a5)+		; a5=index into SaveBuffer
		clr.l	(a5)+			; Setup hunk structure
		move.l	#1,(a5)+
		clr.l	(a5)+
		clr.l	(a5)+
		addq.l	#4,a5			; Skip hunk size
		move.l	#$3e9,(a5)+		; Hunk_code
		addq.l	#4,a5

		move.l	SaveBuffer2,a6		; a6=reloc buffer

		clr.l	(a5)+			; Header
		clr.l	(a5)+
		clr	(a5)+

		addq	#4,a5			; KMName
		move.l	#$4c,(a5)+		; KMLowMapType
		move.l	#$c4,(a5)+		; KMLowMap
		move.l	#$2e,(a5)+		; KMLCapsable
		move.l	#$3d,(a5)+		; KMLRepeatable
		move.l	#$8c,(a5)+		; KMHighMapType
		move.l	#$1c4,(a5)+		; KMHighMap
		move.l	#$36,(a5)+		; KMHCapsable
		move.l	#$45,(a5)+		; KMHRepeatable

		lea	CapsTab,a0		; Do Capsable table
		bsr	MakeBitTab
		lea	ReptTab,a0		; ...and Repeatable
		bsr	MakeBitTab		; table

		lea	KeyTypes,a0		; Do KeyTypes...
		moveq	#0,d0
.loop		move.l	(a0,d0),(a5)+
		addq	#4,d0
		cmpi.b	#$60,d0
		bne	.loop

.loopn		move.b	#KCF_NOP,(a5)+		; clear end of table
		addq	#1,d0
		cmpi.b	#$78,d0
		bne	.loopn

		move.l	a5,SaveDeadBuf1		; Store for deadkeys

		lea	KeyDefs,a0		; ...and KeyDefs
		moveq	#0,d0
.loop2		move.l	(a0,d0),(a5)+
		addq	#4,d0
		cmpi	#4*$60,d0
		bne	.loop2

.loop3		clr.l	(a5)+
		addq	#4,d0
		cmpi	#4*$78,d0
		bne	.loop3

		lea	KeyTypes,a0		; Now deadkeys
		lea	KeyDefs,a1
		moveq	#0,d0
SaveDLoop	lea	DeadTab,a2
		move.b	(a0,d0),d2
		andi.b	#KCF_DEAD,d2
		beq	NoSDead

		move.b	(a0,d0),d2		; Extract a deadkey
		andi.b	#KC_VANILLA,d2
		bsr	QualToIndex		; How many to get?

		move.l	a5,SaveDeadBuf2
		move	d0,d1
		lsl	#4,d1
		add	d1,a2
		moveq	#0,d1
.loop		move	(a2,d1),(a5)+		; Transfer to buffer
		addq	#2,d1
		cmp	d1,d2
		bne	.loop

		moveq	#0,d1
		move.l	SaveDeadBuf2,a4
		lea	DeadIndex,a3
SaveMLoop	cmpi.b	#DPF_MOD,(a4,d1)
		bne.s	NoSMod

		moveq	#0,d3
		move.b	1(a4,d1),d3
		lsl	#4,d3
		move.l	a5,d4
		sub.l	a4,d4
		move.b	d4,1(a4,d1)
		move.l	(a3,d3),(a5)+		; Transfer modkey table
		move.l	4(a3,d3),(a5)+
		move.l	8(a3,d3),(a5)+
		move.l	12(a3,d3),(a5)+

NoSMod		addq	#2,d1
		cmp	d1,d2
		bne	SaveMLoop

		move	d0,d1			; Put address in reloc
		lsl	#2,d1			; table
		move.l	SaveDeadBuf2,d2
		sub.l	SaveBuffer,d2
		subi.l	#32,d2

		move.l	SaveDeadBuf1,a4
		add	d1,a4
		move.l	d2,(a4)
		sub.l	SaveBuffer,a4
		sub.l	#32,a4
		move.l	a4,(a6)+
		bsr	CheckA6

NoSDead		addq	#1,d0
		cmpi	#$60,d0
		bne	SaveDLoop

		lea	KeyTypes,a0		; Finally strings
		lea	KeyDefs,a1
		moveq	#0,d0
SaveSLoop	lea	StringList,a2
		move.b	(a0,d0),d2
		andi.b	#KCF_STRING,d2
		beq	NoSStr

		move.b	(a0,d0),d2		; Extract string key
		andi.b	#KC_VANILLA,d2
		bsr	QualToIndex		; How many to get?
		lsr	#1,d2

		move.l	a5,SaveDeadBuf2
		move	d0,d1
		lsl	#3,d1
		add	d1,a2
		moveq	#0,d1
.loop		move.b	(a2,d1),(a5)+		; Transfer to buffer
		clr.b	(a5)+
		addq	#1,d1
		cmp	d1,d2
		bne	.loop

		lsl	#1,d2
		moveq	#0,d1
		move.l	SaveDeadBuf2,a4
SaveStr		lea	StringArea,a3
		moveq	#0,d3
		move.b	(a4,d1),d3
		lsl	#5,d3
		move.l	a5,d4
		sub.l	a4,d4
		move.b	d4,1(a4,d1)
		moveq	#0,d7			; Transfer string
		add	d3,a3
.loop		move.b	(a3,d7),d6
		beq.s	.loopstop
		move.b	d6,(a5)+
		addq	#1,d7
		bra	.loop

.loopstop	move.b	d7,(a4,d1)
		addq	#2,d1
		cmp	d1,d2
		bne	SaveStr

		move.l	a5,d7
		andi.b	#1,d7
		beq.s	.noalign
		clr.b	(a5)+			; Ensure word-aligned

.noalign	move	d0,d1			; Put address in reloc
		lsl	#2,d1			; table
		move.l	SaveDeadBuf2,d2
		sub.l	SaveBuffer,d2
		subi.l	#32,d2

		move.l	SaveDeadBuf1,a4
		add	d1,a4
		move.l	d2,(a4)
		sub.l	SaveBuffer,a4
		sub.l	#32,a4
		move.l	a4,(a6)+
		bsr	CheckA6

NoSStr		addq	#1,d0
		cmpi	#$60,d0
		bne	SaveSLoop

		move.l	a5,a1
		movea.l	xFile,a0		; Transfer name
		moveq	#0,d0
.loop		move.b	(a0,d0),(a5)+
		beq.s	FinSName
		addq	#1,d0
		bra	.loop

FinSName	move.l	a5,d0
		andi.b	#1,d0
		beq.s	.noalign
		clr.b	(a5)+
.noalign	move.l	SaveBuffer,a0
		move.l	a1,d0
		sub.l	a0,d0
		subi.l	#32,d0
		move.l	d0,42(a0)

		move.l	a5,d0
		andi.l	#3,d0
		beq.s	.noline			; Hunk must be long
		clr	(a5)+			; word aligned

.noline		move.l	a5,d0
		move.l	SaveBuffer,a3
		sub.l	a3,d0			; Get Hunk_size
		subi.l	#$20,d0
		lsr.l	#2,d0
		move.l	d0,$14(a3)		; Save it
		move.l	d0,$1c(a3)
		move.l	#$3ec,(a5)+		; Hunk_reloc32

		move.l	a6,d0
		sub.l	SaveBuffer2,d0
		lsr.l	#2,d0
		addi.l	#9,d0
		move.l	d0,(a5)+		; No. of references
		clr.l	(a5)+			; in Hunk 0

RelocLoop	cmp.l	SaveBuffer2,a6
		beq.s	GotReloc
		move.l	-(a6),d0		; Transfer reloc
		move.l	d0,(a5)+
		bra	RelocLoop

GotReloc	move.l	#$2a,(a5)+		; Refs. to initial table
		move.l	#$26,(a5)+
		move.l	#$22,(a5)+
		move.l	#$1e,(a5)+
		move.l	#$1a,(a5)+
		move.l	#$16,(a5)+
		move.l	#$12,(a5)+
		move.l	#$e,(a5)+
		move.l	#$a,(a5)+

		clr.l	(a5)+			; Termination
		move.l	#$3f2,(a5)+		; Hunk_end
		rts

CheckA6		move.l	SaveBuffer2,a4
		add.l	#5120,a4
		cmpa.l	a4,a6
		bne.s	NotProb
		subq.l	#4,a6
NotProb		rts

QualToIndex	cmpi.b	#KC_NOQUAL,d2
		bne.s	.1
		moveq	#2,d2
		rts
.1		cmpi.b	#KC_VANILLA,d2
		bne.s	.2
		moveq	#16,d2
		rts
.2		cmpi.b	#KCF_SHIFT,d2
		bne.s	.3
		moveq	#4,d2
		rts
.3		cmpi.b	#KCF_ALT,d2
		bne.s	.4
		moveq	#4,d2
		rts
.4		cmpi.b	#KCF_CONTROL,d2
		bne.s	.5
		moveq	#4,d2
		rts
.5		moveq	#8,d2
		rts

MakeBitTab	moveq	#0,d0			; a0 = byte table to
		moveq	#0,d1			; convert to bits
MakeCLoop	bclr	d1,d2
		tst.b	(a0,d0)			; Test key
		beq.s	NoCSet
		bset	d1,d2

NoCSet		addq	#1,d0
		addq	#1,d1
		cmpi.b	#96,d0
		beq.s	MCapsOver
		cmpi.b	#8,d1
		bne	MakeCLoop

		move.b	d2,(a5)+		; Save byte
		moveq	#0,d1
		bra	MakeCLoop

MCapsOver	move.b	d2,(a5)+
		addq	#3,a5
		rts

GoGadget	move	gg_GadgetID(a2),d0	; Which gadget was it?
		cmpi	#90,d0
		beq	GoGadg1
		cmpi	#91,d0
		beq	GoGadg2
		cmpi	#92,d0
		beq	GoGadg3
		cmpi	#93,d0
		beq	GoGadg4
		cmpi	#89,d0
		beq	EndQual
		cmpi	#-1,d0
		beq	GoGadga
		cmpi	#-2,d0
		beq	GoGadgb
		cmpi	#-3,d0
		beq	GoGadgc
		cmpi	#-4,d0
		beq	GoGadgd
		cmpi	#-5,d0
		beq	GoGadge

LoadCheck	cmpi.b	#1,MyMode		; Is it 'Keymap' mode?
		bne	CheckMessage
		clr.b	StringBuf
		move.l	a2,-(sp)
		moveq	#0,d7
		move.b	d0,d7
		move	d7,MyNewKey
		bsr	KeyInString
		move.l	(sp)+,a2
		cmpa.l	MyDefKey,a2		; Is it same key?
		bne.s	NotSame
		bsr	CheckQual
		move.b	d0,d6
		cmp.b	MyDefQual,d6
		bne.s	NotSame
		bra	AllSame

NotSame		movea.l	a2,a4
		bsr	CheckQual		; Store current qualifiers
		move.b	d0,d6

		move.l	Windowhd,a0
		lea	StrGadg,a1
		suba.l	a2,a2
		moveq	#89,d0
		CALLINT	RemoveGList

		movea.l	MyDefKey,a3
		cmpa.l	#0,a3
		beq.s	FirstDef
		cmp.b	MyDefQual,d6
		bne.s	FirstDef

NotFirstDef	move	gg_Flags(a3),d0
		eori	#SELECTED,d0
		move	d0,gg_Flags(a3)

FirstDef	move.b	d6,MyDefQual
		move	gg_Flags(a4),d0
		eori	#SELECTED,d0		; Turn new key on
		move	d0,gg_Flags(a4)
		move.l	a4,MyDefKey

		move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLSYS	AddGList

		movea.l	a4,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList
		move.l	a3,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList
AllSame		move	#GADGHCOMP,StrGadg+gg_Flags
		lea	StrGadg,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLINT	RefreshGList
		bsr	CSIon
		bsr	ActString

		cmpa.l	#Gadg46,a3		; Was any key 'Return'?
		beq.s	DoAnthrGadg
		cmpi.l	#Gadg46,MyDefKey
		bne	CheckMessage

DoAnthrGadg	lea	Gadg87,a0		; If so, refresh key to
		move.l	Windowhd,a1		; the left as well
		moveq	#1,d0
		CALLINT	RefreshGList
		bra	CheckMessage

KeyInString	bsr	CheckQual		; Input: d7 GadgNo.
		move.l	d0,LastQualVal		; a6 safe
		move.l	d7,LastGadgVal
KeyInString2	lsl	#2,d0
		lea	QualTable,a0
		move.l	(a0,d0),NoDeadStore
		lea	DQualTab,a0
		move.l	(a0,d0),DeadStore

		lea	IDtoGadget,a0
		lea	KeyTypes,a2
		lea	KeyDefs,a3
		lea	MapToKeys,a4
		suba.l	#1,a4
		moveq	#0,d2
		moveq	#0,d3
		move.b	(a4,d7),d2		; Keycode in d2
		move.b	(a2,d2),d3		; Get key type
		andi.b	#KCF_STRING,d3
		bne	KI_String
		move.b	(a2,d2),d3
		andi.b	#KCF_DEAD,d3
		bne	KI_Dead
		move.b	(a2,d2),d3
		andi.b	#KC_VANILLA,d3		; Find which key in each
		moveq	#0,d6			; key definition list
		bsr.s	KI_Sub
		cmpi.b	#KC_VANILLA,d3
		bne.s	KI_AllDoF
		move.l	LastQualVal,d4
		andi.b	#1,d4
		beq.s	KI_AllDoF
		andi.b	#KCF_SHIFT!KCF_ALT,d3
		moveq	#0,d6
		bsr.s	KI_Sub
		cmpi.b	#-1,d6
		beq.s	KI_None
		andi.b	#%10011111,d0

KI_AllDoF	cmpi.b	#-1,d6
		beq.s	KI_None
KI_AllDo	move.b	#32,SqrTxt
		tst.b	d0
		beq.s	KI_NoKey
		move.b	d0,SqrTxt
KI_NoKey	move.l	RPort,a0
		lea	SqrText,a1
		clr.b	it_BackPen(a1)
		moveq	#0,d0
		moveq	#0,d1
		CALLINT	PrintIText
KI_None		rts

KI_Sub		move.l	NoDeadStore,a5
		move.b	(a5,d3),d6		; Get index
		moveq	#0,d4			; Extract key from the
		move.b	d2,d4			; 'KeyDefs' table
		lsl	#2,d4
		sub	d6,d4
		move.b	3(a3,d4),d0		; ASCII value in gadget
		rts

KI_Dead		move.b	(a2,d2),d3
		andi.b	#KC_VANILLA,d3
		move.l	DeadStore,a5
		moveq	#0,d1
		move.b	(a5,d3),d1		; Get index
		move.l	a0,d6
		lea	DeadTab,a0
		move	d2,d5
		lsl	#4,d5
		add	d1,d5
		move.b	(a0,d5),d2
		tst.b	d2
		beq.s	KI_DeadDead
		cmpi.b	#DPF_MOD,d2
		beq.s	KI_ModDead
		move.l	d6,a0
		bra	KI_None

KI_DeadDead	move.b	1(a0,d5),d0
		bra	KI_AllDo

KI_ModDead	moveq	#0,d2
		move.b	1(a0,d5),d2
		mulu	#16,d2
		lea	DeadIndex,a0
		moveq	#0,d0
		move.b	CurrDKey,d0
		add	d0,d2
		move.b	(a0,d2),d0
		bra	KI_AllDo

KI_String	move.b	(a2,d2),d3
		andi.b	#KC_VANILLA,d3
		move.l	DeadStore,a5
		moveq	#0,d1
		move.b	(a5,d3),d1		; Get index
		lsr	#1,d1
		lea	StringList,a0
		lsl	#3,d2
		add	d2,d1
		moveq	#0,d3
		move.b	(a0,d1),d3
		lsl	#5,d3
		lea	StringArea,a0
		lea	StringBuf,a1
		moveq	#0,d0
KI_SMove	move.b	(a0,d3),(a1,d0)
		beq.s	KI_SDone
		addq	#1,d3
		addq	#1,d0
		cmpi.b	#32,d0
		bne	KI_SMove
KI_SDone	move	d0,si_BufferPos+SpecialInfo
		clr	si_DispPos+SpecialInfo
		move.b	#" ",SqrTxt
		move.l	RPort,a0
		lea	SqrText,a1
		move.b	#3,it_BackPen(a1)
		moveq	#0,d0
		moveq	#0,d1
		CALLINT	PrintIText
		rts

GoGadg1		move	Gadg91+gg_Flags,d0
		eori	#SELECTED,d0
		move	d0,Gadg91+gg_Flags
		lea	Gadg91,a0		; Redraw gadget
		move.l	Windowhd,a1
		suba.l	a2,a2
		moveq	#1,d0
		CALLINT	RefreshGList
		bra	EndQual

GoGadg2		move	Gadg90+gg_Flags,d0
		eori	#SELECTED,d0
		move	d0,Gadg90+gg_Flags
		lea	Gadg90,a0
		move.l	Windowhd,a1
		suba.l	a2,a2
		moveq	#1,d0
		CALLINT	RefreshGList
		bra.s	EndQual

GoGadg3		move	Gadg93+gg_Flags,d0
		eori	#SELECTED,d0
		move	d0,Gadg93+gg_Flags
		lea	Gadg93,a0
		move.l	Windowhd,a1
		suba.l	a2,a2
		moveq	#1,d0
		CALLINT	RefreshGList
		bra.s	EndQual

GoGadg4		move	Gadg92+gg_Flags,d0
		eori	#SELECTED,d0
		move	d0,Gadg92+gg_Flags
		lea	Gadg92,a0
		move.l	Windowhd,a1
		suba.l	a2,a2
		moveq	#1,d0
		CALLINT	RefreshGList

EndQual		bsr	RedrawKeys		; Perform routines common
		bsr	SortOutFlag		; to all qualifier keys
		cmpi.b	#5,MyMode		; If 'DeadKeys', select
		bne.s	GoEQual1		; dead & ghost modifiable
		move.b	#DPF_DEAD,DeadByte
		bsr	PickUpDead
		bsr	CancelMod
		bsr	NoOfDead
		bsr	CancelString
		bsr	NoOfDead

GoEQual1	cmpi.b	#4,MyMode		; If 'Modifiable', select
		bne.s	GoEQual2		; modifiable & ghost dead
		move.b	#DPF_MOD,DeadByte
		bsr	PickUpDead
		bsr	CancelDead
		bsr	CancelString
		bsr	NoOfMod

GoEQual2	cmpi.b	#1,MyMode		; If 'KeyMap', ghost dead
		bne.s	GoEQual3
		bsr	CancelDead
		bsr	SetUpKeyOn
		bsr	ActString

GoEQual3	bsr	ERedrawKeys		; Complete and RefreshGList()
		bra	CheckMessage

GoGadga		cmpi.b	#1,MyMode
		beq	CheckMessage
GGadga		bsr	StartExclude
		move.b	#1,MyMode
		move	#GADGHCOMP!GADGIMAGE!SELECTED,Gadg0a+gg_Flags
		bsr	EndExclude
		bsr	GoGadgKey
		bsr	SNoToggleGadg
		bsr	CancelDead
		bsr	SetUpKeyOn
		bsr	ENoToggleGadg
		bsr	ActString
		bsr	ChangeKString
		bra	CheckMessage

GoGadgb		cmpi.b	#2,MyMode
		beq	CheckMessage
GGadgb		bsr	StartExclude
		move.b	#2,MyMode
		move	#GADGHCOMP!GADGIMAGE!SELECTED,Gadg0b+gg_Flags
		bsr	EndExclude
		bsr	GoGadgCap
		bsr	SToggleGadg
		bsr	SetupCaps
		bsr	EToggleGadg
		bra	CheckMessage

GoGadgc		cmpi.b	#3,MyMode
		beq	CheckMessage
GGadgc		bsr	StartExclude
		move.b	#3,MyMode
		move	#GADGHCOMP!GADGIMAGE!SELECTED,Gadg0c+gg_Flags
		bsr	EndExclude
		bsr	GoGadgCap
		bsr	SToggleGadg
		bsr	SetUpRept
		bsr	EToggleGadg
		bra	CheckMessage

GoGadgd		cmpi.b	#4,MyMode
		beq	CheckMessage
GGadgd		bsr	StartExclude
		move.b	#4,MyMode
		move	#GADGHCOMP!GADGIMAGE!SELECTED,Gadg0d+gg_Flags
		bsr	EndExclude
		bsr	GoGadgKey
		bsr	SToggleGadg
		move.b	#DPF_MOD,DeadByte
		bsr	PickUpDead
		bsr.s	CancelDead
		bsr	CancelString
		bsr	NoOfMod
		bsr	EToggleGadg
		bra	CheckMessage

GoGadge		cmpi.b	#5,MyMode
		beq	CheckMessage
GGadge		bsr.s	StartExclude
		move.b	#5,MyMode
		move	#GADGHCOMP!GADGIMAGE!SELECTED,Gadg0e+gg_Flags
		bsr	EndExclude
		bsr	GoGadgKey
		bsr	SToggleGadg
		move.b	#DPF_DEAD,DeadByte
		bsr	PickUpDead
		bsr.s	CancelMod
		bsr	CancelString
		bsr	NoOfDead
		bsr	EToggleGadg
		bra	CheckMessage

CancelDead	move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,On_Value
		move.b	#DPF_DEAD,DeadByte
		bsr	PickUpDead
		move	#GADGHCOMP!GADGIMAGE!SELECTED,On_Value
		rts

CancelMod	move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,On_Value
		move.b	#DPF_MOD,DeadByte
		bsr	PickUpDead
		move	#GADGHCOMP!GADGIMAGE!SELECTED,On_Value
		rts

StartExclude	bsr	CheckQual
		lsl	#2,d0
		lea	QualTable,a0
		move.l	(a0,d0),NoDeadStore
		lea	DQualTab,a0
		move.l	(a0,d0),DeadStore

		move.l	Windowhd,a0		; Turn off all mode gadgets
		lea	Gadg0a,a1
		moveq	#5,d0
		CALLINT	RemoveGList
		move	#GADGHCOMP!GADGIMAGE,d0
		move	d0,Gadg0a+gg_Flags
		move	#GADGHCOMP!GADGIMAGE,d0
		move	d0,Gadg0b+gg_Flags
		move	#GADGHCOMP!GADGIMAGE,d0
		move	d0,Gadg0c+gg_Flags
		move	#GADGHCOMP!GADGIMAGE,d0
		move	d0,Gadg0d+gg_Flags
		move	#GADGHCOMP!GADGIMAGE,d0
		move	d0,Gadg0e+gg_Flags
		rts

EndExclude	move.l	Windowhd,a0
		lea	Gadg0a,a1
		moveq	#0,d0
		moveq	#5,d1
		suba.l	a2,a2
		CALLINT	AddGList		; Turn on all mode gadgets

		lea	Gadg0a,a0
		move.l	Windowhd,a1
		moveq	#5,d0
		CALLSYS	RefreshGList		; ...and redraw them
		rts

GoGadgCap	move	Gadg89+gg_Flags,d0	; Do we need to alter any
		andi	#GADGDISABLED,d0	; gadgets for the new mode?
		beq.s	SendGadgCap		; Yes, so branch
		rts

SendGadgCap	move.l	Windowhd,a0		; Deactivate qualifiers
		lea	Gadg89,a1
		moveq	#5,d0
		CALLINT	RemoveGList

		move	Gadg89+gg_Flags,d0	; then turn them off
		ori	#GADGDISABLED,d0	; similarly to OffGadget()
		move	d0,Gadg89+gg_Flags
		move	Gadg90+gg_Flags,d0
		ori	#GADGDISABLED,d0
		move	d0,Gadg90+gg_Flags
		move	Gadg91+gg_Flags,d0
		ori	#GADGDISABLED,d0
		move	d0,Gadg91+gg_Flags
		move	Gadg92+gg_Flags,d0
		ori	#GADGDISABLED,d0
		move	d0,Gadg92+gg_Flags
		move	Gadg93+gg_Flags,d0
		ori	#GADGDISABLED,d0
		move	d0,Gadg93+gg_Flags

		move.l	Windowhd,a0
		lea	Gadg89,a1
		moveq	#5+89,d0
		moveq	#5,d1
		CALLSYS	AddGList

		lea	Gadg89,a0		; and redraw
		move.l	Windowhd,a1
		moveq	#5,d0
		CALLSYS	RefreshGList
		rts

GoGadgKey	move	Gadg89+gg_Flags,d0	; Do we need to alter any
		andi	#GADGDISABLED,d0	; gadgets for the new mode?
		bne.s	SendGadgKey		; Yes, so branch
		rts

SendGadgKey	move.l	Windowhd,a0		; Deactivate qualifiers
		lea	Gadg89,a1
		moveq	#5,d0
		CALLINT	RemoveGList

		move	Gadg89+gg_Flags,d0	; then turn them on
		eori	#GADGDISABLED,d0	; similarly to OnGadget()
		move	d0,Gadg89+gg_Flags
		move	Gadg90+gg_Flags,d0
		eori	#GADGDISABLED,d0
		move	d0,Gadg90+gg_Flags
		move	Gadg91+gg_Flags,d0
		eori	#GADGDISABLED,d0
		move	d0,Gadg91+gg_Flags
		move	Gadg92+gg_Flags,d0
		eori	#GADGDISABLED,d0
		move	d0,Gadg92+gg_Flags
		move	Gadg93+gg_Flags,d0
		eori	#GADGDISABLED,d0
		move	d0,Gadg93+gg_Flags

		move.l	Windowhd,a0
		lea	Gadg89,a1
		moveq	#5+89,d0
		moveq	#5,d1
		suba.l	a2,a2
		CALLSYS	AddGList

		lea	Gadg89,a0		; and redraw
		move.l	Windowhd,a1
		moveq	#5,d0
		CALLSYS	RefreshGList
		rts

SToggleGadg	move.l	Windowhd,a0
		CALLINT	ClearDMRequest
		move.l	Windowhd,a0		; Deactivate keys
		lea	StrGadg,a1
		moveq	#89,d0
		CALLSYS	RemoveGList

		move	#RELVERIFY!TOGGLESELECT,d0
		move	#gg_Activation,d1
		moveq	#0,d2
		lea	DeadIDtoGadg,a0
STGadgLoop	move.l	(a0,d2),a1
		move	d0,(a1,d1)
		addq	#4,d2
		cmpi	#88*4,d2
		bne	STGadgLoop

		move	#RELVERIFY!TOGGLESELECT!BOOLEXTEND,Gadg46+gg_Activation
		move	#GADGHCOMP!GADGDISABLED,StrGadg+gg_Flags
		bsr	CSIoff
		bra	SortOutFlag

EToggleGadg	move.l	Windowhd,a0		; Finish & redraw
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	StrGadg,a0
		move.l	Windowhd,a1
		moveq	#89,d0
		CALLSYS	RefreshGList
		rts

SNoToggleGadg	move.l	Windowhd,a0		; Turn on requester
		lea	DoubleReq,a1
		CALLINT	SetDMRequest
		move.l	Windowhd,a0		; Deactivate keys
		lea	StrGadg,a1
		moveq	#89,d0
		CALLSYS	RemoveGList

		move	#GADGIMMEDIATE,d0
		move	#gg_Activation,d1
		moveq	#0,d2
		lea	DeadIDtoGadg,a0
STNoGadgLp	move.l	(a0,d2),a1
		move	d0,(a1,d1)
		addq	#4,d2
		cmpi	#88*4,d2
		bne	STNoGadgLp

		move	#GADGIMMEDIATE!BOOLEXTEND,Gadg46+gg_Activation
		bra.s	SortOutFlag

ENoToggleGadg	move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	StrGadg,a0
		move.l	Windowhd,a1
		moveq	#89,d0
		CALLSYS	RefreshGList
		rts

SortOutFlag	move	#GADGHCOMP!GADGIMAGE,d0
		move	#gg_Flags,d1
		moveq	#0,d2
		lea	DeadIDtoGadg,a0
SFlagLoop	move.l	(a0,d2),a1
		move	d0,(a1,d1)
		addq	#4,d2
		cmpi	#88*4,d2
		bne	SFlagLoop
		rts

SetupCaps	lea	CapsTab,a0		; Analyse Caps table
		bra.s	BitInfo

SetUpRept	lea	ReptTab,a0		; Analyse Repeat table

BitInfo		lea	KeysToMap,a1
		moveq	#0,d0
		moveq	#0,d1
BitLoop		move.b	(a0,d0),d2
		move.l	(a1,d1),a3
		cmpa	#0,a3			; Is it a valid key?
		beq.s	EBit
		adda	#gg_Flags,a3
		tst.b	d2			; Is it high?
		beq.s	NotBit			; No...
		move	#GADGHCOMP!GADGIMAGE!SELECTED,(a3)
		bra.s	EBit
NotBit		move	#GADGHCOMP!GADGIMAGE,(a3)
EBit		addi	#4,d1			; Continue loop
		addi	#1,d0
		cmpi	#$60,d0
		bne	BitLoop
		rts

KeyGadget	move	gg_GadgetID(a2),d0	; Now process normal keys
		cmpi	#94,d0
		beq.s	CSIenter
		cmpi.b	#1,MyMode
		beq.s	OnKeyEd
		cmpi.b	#2,MyMode
		beq	OnCaps
		cmpi.b	#3,MyMode
		beq	OnRept
		cmpi.b	#4,MyMode
		beq	OnMod
		cmpi.b	#5,MyMode
		beq	OnDead
		bra	CheckMessage

CSIenter	move	#$9b00,StringBuf
		move	#1,si_BufferPos+SpecialInfo
		clr	si_DispPos+SpecialInfo
		lea	StrGadg,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLINT	RefreshGList
		bsr	ActString
		bra	CheckMessage

OnKeyEd		tst	d0			; Has a string been entered?
		bne	CheckMessage
		tst.b	StringBuf
		beq	CheckMessage
		lea	StringBuf,a0
		lea	SoM,a1
		bsr	StrComp
		tst	d0
		bne.s	NotSpecString
		bsr	Sisters

NotSpecString	tst.b	StringBuf+1		; Process string
		bne	StringEnter		; User entered string

		lea	KeyTypes,a4		; Handle single key input
		lea	MapToKeys,a2
		suba.l	#1,a2
		moveq	#0,d7
		move	MyNewKey,d2
		move.b	(a2,d2),d7
		move.b	(a4,d7),d1		; Get key type
		andi.b	#KCF_STRING,d1
		bne	EdOneString		; User modifies string
		move.b	(a4,d7),d1
		andi.b	#KCF_DEAD,d1
		bne	EditDead		; User modifies deadkey

		move.b	(a4,d7),d1		; Replace one single char
		move.b	MyDefQual,d2		; definition with another
		cmpi.b	#7,d2
		beq	Ed_NoGo
		cmpi.b	#1,d2			; Do we have to reorganise
		beq.s	Ed___C			; the KeyDefinition?
		cmpi.b	#2,d2
		beq.s	Ed_S__
		cmpi.b	#3,d2
		beq.s	Ed_S_C
		cmpi.b	#4,d2
		beq.s	Ed__A_
		cmpi.b	#5,d2
		beq	Ed__AC
		cmpi.b	#6,d2
		beq.s	Ed_SA_
		bra	Ed_Go

Ed___C		cmpi.b	#KCF_ALT+KCF_SHIFT,d1
		beq.s	Ed_MustFix_1
		cmpi.b	#KC_VANILLA,d1
		bne	Ed_Go
Ed_MustFix_1	bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		move.b	#KCF_SHIFT,(a4,d7)
		bra.s	Ed_Go

Ed_S__		cmpi.b	#KCF_ALT+KCF_CONTROL,d1
		bne.s	Ed_Go
		bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		move.b	#KCF_ALT,(a4,d7)
		bra.s	Ed_Go

Ed__A_		cmpi.b	#KCF_CONTROL+KCF_SHIFT,d1
		bne.s	Ed_Go
		bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		move.b	#KCF_SHIFT,(a4,d7)
		bra.s	Ed_Go

Ed_S_C		andi.b	#KCF_ALT,d1
		beq.s	Ed_Go
		bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		eori.b	#KCF_ALT,(a4,d7)
		bra.s	Ed_Go

Ed_SA_		cmpi.b	#KC_VANILLA,d1
		beq.s	Ed_Go
		andi.b	#KCF_CONTROL,d1
		beq.s	Ed_Go
		bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		eori.b	#KCF_CONTROL,(a4,d7)
		bra.s	Ed_Go

Ed__AC		andi.b	#KCF_SHIFT,d1
		beq.s	Ed_Go
		bsr	Ed_MustFix
		tst	d0
		beq	CheckMessage
		eori.b	#KCF_SHIFT,(a4,d7)

Ed_Go		lea	KeyDefs,a0		; Change key definition
		move.b	MyDefQual,d2
		move.b	(a4,d7),d1
		move	d7,d6
		lsl	#2,d6
		cmpi.b	#KC_NOQUAL,d1
		beq.s	Eg____
		cmpi.b	#KCF_SHIFT,d1
		beq	Eg_S__
		cmpi.b	#KCF_ALT,d1
		beq	Eg__A_
		cmpi.b	#KCF_CONTROL,d1
		beq	Eg___C
		cmpi.b	#KCF_SHIFT+KCF_ALT,d1
		beq	Eg_SA_
		cmpi.b	#KCF_SHIFT+KCF_CONTROL,d1
		beq	Eg_S_C
		cmpi.b	#KCF_ALT+KCF_CONTROL,d1
		beq	Eg__AC
		cmpi.b	#KC_VANILLA,d1
		beq	Eg_SA_

Eg____		tst.b	d2
		bne.s	.1
		move.b	#KC_NOQUAL,(a4,d7)
		move.b	StringBuf,3(a0,d6)
		bra	Eg_Done
.1		cmpi.b	#1,d2
		bne.s	.2
		move.b	#KCF_CONTROL,(a4,d7)
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.2		cmpi.b	#2,d2
		bne.s	.3
		move.b	#KCF_SHIFT,(a4,d7)
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.3		cmpi.b	#4,d2
		bne.s	.4
		move.b	#KCF_ALT,(a4,d7)
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.4		cmpi.b	#3,d2
		bne.s	.5
		move.b	#KCF_SHIFT+KCF_CONTROL,(a4,d7)
		move.b	3(a0,d6),2(a0,d6)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done
.5		cmpi.b	#5,d2
		bne.s	.6
		move.b	#KCF_CONTROL+KCF_ALT,(a4,d7)
		move.b	3(a0,d6),2(a0,d6)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done
.6		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		move.b	3(a0,d6),2(a0,d6)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bsr	VanOrNot
		bra	Eg_Done

Eg_S__		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra	Eg_Done
.1		cmpi.b	#2,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.2		cmpi.b	#4,d2
		bne.s	.3
		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,1(a0,d6)
		bsr	VanOrNot
		bra	Eg_Done
.3		cmpi.b	#6,d2
		bne.s	.4
		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bsr	VanOrNot
		bra	Eg_Done
.4		cmpi.b	#1,d2
		bne.s	.5
		move.b	#KCF_SHIFT+KCF_CONTROL,(a4,d7)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,1(a0,d6)
		bra	Eg_Done
.5		move.b	#KCF_SHIFT+KCF_CONTROL,(a4,d7)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done

Eg__A_		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra	Eg_Done
.1		cmpi.b	#4,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.2		cmpi.b	#2,d2
		bne.s	.3
		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,2(a0,d6)
		bsr	VanOrNot
		bra	Eg_Done
.3		cmpi.b	#6,d2
		bne.s	.4
		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bsr	VanOrNot
		bra	Eg_Done
.4		cmpi.b	#1,d2
		bne.s	.5
		move.b	#KCF_ALT+KCF_CONTROL,(a4,d7)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,1(a0,d6)
		bra	Eg_Done
.5		move.b	#KCF_CONTROL+KCF_ALT,(a4,d7)
		move.b	3(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done

Eg___C		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra	Eg_Done
.1		cmpi.b	#1,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.2		cmpi.b	#2,d2
		bne.s	.3
		move.b	#KCF_SHIFT+KCF_CONTROL,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.3		cmpi.b	#3,d2
		bne.s	.4
		move.b	#KCF_SHIFT+KCF_CONTROL,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done
.4		cmpi.b	#4,d2
		bne.s	.5
		move.b	#KCF_ALT+KCF_CONTROL,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	2(a0,d6),(a0,d6)
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.5		move.b	#KCF_CONTROL+KCF_ALT,(a4,d7)
		move.b	2(a0,d6),1(a0,d6)
		move.b	StringBuf,(a0,d6)
		bra	Eg_Done

Eg_SA_		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra	Eg_Done
.1		cmpi.b	#2,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra	Eg_Done
.2		cmpi.b	#4,d2
		bne.s	.3
		move.b	StringBuf,1(a0,d6)
		bra.s	Eg_Done
.3		move.b	StringBuf,(a0,d6)
		bra.s	Eg_Done

Eg_S_C		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra.s	Eg_Done
.1		cmpi.b	#2,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra.s	Eg_Done
.2		cmpi.b	#1,d2
		bne.s	.3
		move.b	StringBuf,1(a0,d6)
		bra.s	Eg_Done
.3		move.b	StringBuf,(a0,d6)
		bra.s	Eg_Done

Eg__AC		tst.b	d2
		bne.s	.1
		move.b	StringBuf,3(a0,d6)
		bra.s	Eg_Done
.1		cmpi.b	#4,d2
		bne.s	.2
		move.b	StringBuf,2(a0,d6)
		bra.s	Eg_Done
.2		cmpi.b	#1,d2
		bne.s	.3
		move.b	StringBuf,1(a0,d6)
		bra.s	Eg_Done
.3		move.b	StringBuf,(a0,d6)

Eg_Done		move.l	Windowhd,a0		; Redraw affected key
		lea	StrGadg,a1
		moveq	#89,d0
		CALLINT	RemoveGList
		bsr	GenerateKeys
		move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	DeadIDtoGadg,a0
		move	MyNewKey,d7
		subq	#1,d7
		move	d7,d0
		lsl	#2,d0
		move.l	(a0,d0),a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList

		cmpi	#45,d7
		bne.s	Eg_FinalCall
		lea	Gadg87,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList
Eg_FinalCall	bsr	ChangeKString
		bra	CheckMessage

Ed_MustFix	move.l	Windowhd,a0		; What should we do?
		lea	EdText,a1
		lea	EdPos,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move.l	#320,d2
		moveq	#62,d3
		CALLINT	AutoRequest
		rts

Ed_NoGo		move.l	Windowhd,a0
		lea	NoEdText,a1
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move.l	#325,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	CheckMessage

VanOrNot	move.l	Windowhd,a0		; What should we do
		lea	VanText,a1		; about CTRL key?
		lea	VanPos,a2
		lea	VanNeg,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#397,d2
		moveq	#62,d3
		CALLINT	AutoRequest
		tst.l	d0
		bne.s	ChangeToVan
		rts
ChangeToVan	move.b	#KC_VANILLA,(a4,d7)
		rts

EditDead	moveq	#0,d0
		move.b	MyDefQual,d0
		lsl	#2,d0
		lea	DQualTab,a0
		move.l	(a0,d0),a6

		move.b	(a4,d7),d1
		andi.b	#KC_VANILLA,d1
		moveq	#0,d0
		move.b	(a6,d1),d0
		lea	DeadTab,a5
		move	d7,d6
		lsl	#4,d6
		add	d0,d6
		move.b	(a5,d6),d2
		cmpi.b	#DPF_MOD,d2
		beq.s	EditMod
		tst.b	d2
		bne	CheckMessage
		move.b	StringBuf,1(a5,d6)	; Store new definition
		bra	Eg_Done

EditMod		moveq	#0,d0
		move.b	1(a5,d6),d0
		lsl	#4,d0
		add.b	CurrDKey,d0
		lea	DeadIndex,a0
		move.b	StringBuf,(a0,d0)
		bra	Eg_Done

StringEnter	lea	KeyTypes,a4		; Handle string input
		lea	MapToKeys,a2
		suba.l	#1,a2
		moveq	#0,d7
		move	MyNewKey,d2
		move.b	(a2,d2),d7
		move.b	(a4,d7),d1		; Get key type
		andi.b	#KCF_STRING,d1
		bne	EditString
		move.b	(a4,d7),d1
		andi.b	#KCF_DEAD,d1
		beq	NormToStr		; Convert to string

		move.l	Windowhd,a0		; Cannot put a string on
		lea	NoDeadSText,a1		; a deadkey
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move.l	#357,d2
		moveq	#53,d3
		CALLINT	AutoRequest
		bra	CheckMessage

EdOneString	move.b	(a4,d7),d1		; Current keytype
		andi.b	#KC_VANILLA,d1
		move.b	MyDefQual,d2		; Qualifier
		bsr	StringExpand

		move.l	DeadStore,a5		; Now edit string
		move	d7,d2
		move.b	(a4,d2),d3
		andi.b	#KC_VANILLA,d3
		moveq	#0,d1
		move.b	(a5,d3),d1		; Get index
		lsr	#1,d1
		lea	StringList,a0
		lsl	#3,d2
		add	d2,d1
		moveq	#0,d3
		move.b	(a0,d1),d3
		lsl	#5,d3
		lea	StringArea,a0
		lea	StringBuf,a1
		move.b	(a1),(a0,d3)		; Copy key entered
		clr.b	1(a0,d3)

		lea	StringList,a1
		adda	d2,a1
		move.b	(a4,d7),d6
		andi.b	#KC_VANILLA,d6
		moveq	#0,d1
ExStrLoop	moveq	#0,d3			; Can we turn this key
		move.b	(a1,d1),d3		; back to a normal?
		lsl	#5,d3
		tst.b	1(a0,d3)
		bne	Eg_Done			; No...

		addq	#1,d1
		cmpi.b	#KC_NOQUAL,d6
		beq.s	PassStrTest
		cmpi.b	#KCF_SHIFT,d6
		beq.s	.1
		cmpi.b	#KCF_ALT,d6
		beq.s	.1
		cmpi.b	#KCF_CONTROL,d6
		beq.s	.1
		cmpi.b	#KC_VANILLA,d6
		beq.s	.2

		cmpi.b	#4,d1
		beq.s	PassStrTest
		bra	ExStrLoop

.1		cmpi.b	#2,d1
		beq.s	PassStrTest
		bra	ExStrLoop

.2		cmpi.b	#8,d1
		beq.s	PassStrTest
		bra	ExStrLoop

PassStrTest	cmpi.b	#KC_VANILLA,d6
		bne.s	NoCheckNeed

		movem.l	a0-a1,-(sp)
		move.l	Windowhd,a0
		lea	ZapText1,a1
		lea	EdPos,a2
		lea	ZapNo,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#415,d2
		moveq	#71,d3
		CALLINT	AutoRequest
		movem.l	(sp)+,a0-a1

		tst.l	d0
		beq	Eg_Done
		move.b	#KCF_STRING+KCF_SHIFT+KCF_ALT,(a4,d7)
		moveq	#0,d3			; Remove CTRL defs
		move.b	4(a1),d3
		lsl	#5,d3
		clr	(a0,d3)
		moveq	#0,d3
		move.b	5(a1),d3
		lsl	#5,d3
		clr	(a0,d3)
		moveq	#0,d3
		move.b	6(a1),d3
		lsl	#5,d3
		clr	(a0,d3)
		moveq	#0,d3
		move.b	7(a1),d3
		lsl	#5,d3
		clr	(a0,d3)

NoCheckNeed	move.b	(a4,d7),d5		; Turn string back to
		andi.b	#KC_VANILLA,d5		; normal keytype
		move	d7,d6
		lsl	#2,d6
		lea	KeyDefs,a2

		moveq	#0,d3
		move.b	(a1),d3
		lsl	#5,d3
		move.b	(a0,d3),3(a2,d6)
		clr	(a0,d3)
		cmpi.b	#KC_NOQUAL,d5
		beq.s	StrChkOver

		moveq	#0,d3
		move.b	1(a1),d3
		lsl	#5,d3
		move.b	(a0,d3),2(a2,d6)
		clr	(a0,d3)
		cmpi.b	#KCF_SHIFT,d5
		beq.s	StrChkOver
		cmpi.b	#KCF_ALT,d5
		beq.s	StrChkOver
		cmpi.b	#KCF_CONTROL,d5
		beq.s	StrChkOver

		moveq	#0,d3
		move.b	2(a1),d3
		lsl	#5,d3
		move.b	(a0,d3),1(a2,d6)
		clr	(a0,d3)
		moveq	#0,d3
		move.b	3(a1),d3
		lsl	#5,d3
		move.b	(a0,d3),(a2,d6)
		clr	(a0,d3)

StrChkOver	andi.b	#$ff-KCF_STRING,(a4,d7)
		bsr	SortStringNow

		cmpi.b	#KCF_SHIFT+KCF_ALT,d5
		bne	Eg_Done

		move.l	Windowhd,a0		; What should we do
		lea	VanText,a1		; about CTRL key?
		lea	VanPos,a2
		lea	VanNeg,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#397,d2
		moveq	#62,d3
		CALLINT	AutoRequest
		tst.l	d0
		beq	Eg_Done
		move.b	#KC_VANILLA,(a4,d7)
		bra	Eg_Done

EditString	move.b	(a4,d7),d1		; Current keytype
		andi.b	#KC_VANILLA,d1
		move.b	MyDefQual,d2		; Qualifier
		bsr.s	StringExpand

		move.l	DeadStore,a5		; Now edit string
		move	d7,d2
		move.b	(a4,d2),d3
		andi.b	#KC_VANILLA,d3
		moveq	#0,d1
		move.b	(a5,d3),d1		; Get index
		lsr	#1,d1
		lea	StringList,a0
		lsl	#3,d2
		add	d2,d1
		moveq	#0,d3
		move.b	(a0,d1),d3
		lsl	#5,d3
		lea	StringArea,a0
		lea	StringBuf,a1
		moveq	#0,d0
EdStrLoop	move.b	(a1,d0),(a0,d3)		; Copy string entered
		beq	Eg_Done			; to main buffers
		addq	#1,d3
		addq	#1,d0
		cmpi.b	#32,d0
		bne	EdStrLoop

StringExpand	lea	StringList,a0		; d1=keytype of key,
		move	d7,d6			; d2=keytype to be added
		lsl	#3,d6			; d7=keyno, a4=keytypes

		cmpi.b	#KC_NOQUAL,d1
		beq	Str___
		cmpi.b	#KCF_SHIFT,d1
		beq	StrS__
		cmpi.b	#KCF_ALT,d1
		beq	Str_A_
		cmpi.b	#KCF_CONTROL,d1
		beq	Str__C
		cmpi.b	#KCF_SHIFT+KCF_ALT,d1
		beq	StrSA_
		cmpi.b	#KCF_SHIFT+KCF_CONTROL,d1
		beq.s	StrS_C
		cmpi.b	#KCF_ALT+KCF_CONTROL,d1
		beq.s	Str_AC
		rts				; If KC_VANILLA then return

Str_AC		andi.b	#2,d2
		bne.s	.1
		rts
.1		move.b	3(a0,d6),6(a0,d6)
		move.b	2(a0,d6),4(a0,d6)
		move.b	1(a0,d6),2(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts

StrS_C		andi.b	#4,d2
		bne.s	.1
		rts
.1		move.b	2(a0,d6),4(a0,d6)
		move.b	3(a0,d6),5(a0,d6)
		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts

StrSA_		andi.b	#1,d2
		bne.s	.1
		rts
.1		lea	4(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts

Str__C		cmpi.b	#2,d2
		beq.s	.1
		cmpi.b	#4,d2
		beq.s	.2
		cmpi.b	#3,d2
		beq.s	.1
		cmpi.b	#5,d2
		beq.s	.2
		cmpi.b	#6,d2
		beq.s	.3
		cmpi.b	#7,d2
		beq.s	.3
		rts
.3		move.b	1(a0,d6),4(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts
.2		move.b	1(a0,d6),2(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_ALT+KCF_CONTROL,(a4,d7)
		rts
.1		move.b	1(a0,d6),2(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_SHIFT+KCF_CONTROL,(a4,d7)
		rts

Str_A_		cmpi.b	#1,d2
		beq.s	.1
		cmpi.b	#2,d2
		beq.s	.2
		cmpi.b	#3,d2
		beq.s	.3
		cmpi.b	#5,d2
		beq.s	.1
		cmpi.b	#6,d2
		beq.s	.2
		cmpi.b	#7,d2
		beq.s	.3
		rts
.3		move.b	1(a0,d6),2(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	4(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts
.2		move.b	1(a0,d6),2(a0,d6)
		lea	1(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_SHIFT+KCF_ALT,(a4,d7)
		rts
.1		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_CONTROL+KCF_ALT,(a4,d7)
		rts

StrS__		cmpi.b	#1,d2
		beq.s	.1
		cmpi.b	#4,d2
		beq.s	.2
		cmpi.b	#3,d2
		beq.s	.1
		cmpi.b	#5,d2
		beq.s	.3
		cmpi.b	#6,d2
		beq.s	.2
		cmpi.b	#7,d2
		beq.s	.3
		rts
.3		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	4(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts
.2		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_SHIFT+KCF_ALT,(a4,d7)
		rts
.1		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KCF_SHIFT+KCF_CONTROL,(a4,d7)
		rts

Str___		cmpi.b	#1,d2
		beq	.1
		cmpi.b	#2,d2
		beq	.2
		cmpi.b	#4,d2
		beq	.3
		cmpi.b	#3,d2
		beq	.4
		cmpi.b	#5,d2
		beq.s	.5
		cmpi.b	#6,d2
		beq.s	.6
		cmpi.b	#7,d2
		beq.s	.7
		rts
.7		lea	1(a0,d6),a1
		bsr	GetStr
		lea	2(a0,d6),a1
		bsr	GetStr
		lea	3(a0,d6),a1
		bsr	GetStr
		lea	4(a0,d6),a1
		bsr	GetStr
		lea	5(a0,d6),a1
		bsr	GetStr
		lea	6(a0,d6),a1
		bsr	GetStr
		lea	7(a0,d6),a1
		bsr	GetStr
		move.b	#KCF_STRING+KC_VANILLA,(a4,d7)
		rts
.6		lea	1(a0,d6),a1
		bsr.s	GetStr
		lea	2(a0,d6),a1
		bsr.s	GetStr
		lea	3(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_SHIFT+KCF_ALT,(a4,d7)
		rts
.5		lea	1(a0,d6),a1
		bsr.s	GetStr
		lea	2(a0,d6),a1
		bsr.s	GetStr
		lea	3(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_CONTROL+KCF_ALT,(a4,d7)
		rts
.4		lea	1(a0,d6),a1
		bsr.s	GetStr
		lea	2(a0,d6),a1
		bsr.s	GetStr
		lea	3(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_CONTROL+KCF_SHIFT,(a4,d7)
		rts
.3		lea	1(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_ALT,(a4,d7)
		rts
.2		lea	1(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_SHIFT,(a4,d7)
		rts
.1		lea	1(a0,d6),a1
		bsr.s	GetStr
		move.b	#KCF_STRING+KCF_CONTROL,(a4,d7)
		rts

GetStr		bsr.s	PickUpNew
		moveq	#0,d4
		move.b	(a0,d6),d4
		lsl	#5,d4
		move	StringNow,d5
		lsl	#5,d5
		lea	StringArea,a3
		move.l	(a3,d4),(a3,d5)
		move.l	4(a3,d4),4(a3,d5)
		move.l	8(a3,d4),8(a3,d5)
		move.l	12(a3,d4),12(a3,d5)
		move.l	16(a3,d4),16(a3,d5)
		move.l	20(a3,d4),20(a3,d5)
		move.l	24(a3,d4),24(a3,d5)
		move.l	28(a3,d4),28(a3,d5)
		rts

PickUpNew	bsr	SortStringNow
		cmpi	#$100,StringNow
		beq.s	FullUp
		move.b	StringNow+1,(a1)
		rts

FullUp		move.b	(a0,d6),(a1)
		rts

NormToStr	move.b	(a4,d7),d1		; Convert normal key
		andi.b	#KC_VANILLA,d1		; to string definition
		lea	StringArea,a0
		lea	StringList,a1
		lea	KeyDefs,a2
		move	d7,d6
		lsl	#2,d6
		move	d6,d5
		lsl	#1,d5

		cmpi.b	#KCF_SHIFT,d1
		beq.s	Norm1ToStr
		cmpi.b	#KCF_ALT,d1
		beq.s	Norm1ToStr
		cmpi.b	#KCF_CONTROL,d1
		beq.s	Norm1ToStr
		cmpi.b	#KCF_SHIFT+KCF_ALT,d1
		beq.s	Norm2ToStr
		cmpi.b	#KCF_SHIFT+KCF_CONTROL,d1
		beq.s	Norm2ToStr
		cmpi.b	#KCF_CONTROL+KCF_ALT,d1
		beq.s	Norm2ToStr
		cmpi.b	#KC_VANILLA,d1
		bne.s	Norm0ToStr
		move.b	#KCF_SHIFT+KCF_ALT,(a4,d7)
		bra.s	Norm2ToStr

Norm0ToStr	bsr	SortStringNow
		move	StringNow,d4
		move.b	d4,(a1,d5)
		lsl	#5,d4
		move.b	3(a2,d6),(a0,d4)	; Turn byte definition
		andi.b	#$ff-KCF_NOP,(a4,d7)
		ori.b	#KCF_STRING,(a4,d7)	; into a string
		bra	EditString

Norm1ToStr	bsr	SortStringNow
		move	StringNow,d4
		move.b	d4,1(a1,d5)
		lsl	#5,d4
		move.b	2(a2,d6),(a0,d4)
		bra	Norm0ToStr

Norm2ToStr	bsr	SortStringNow
		move	StringNow,d4
		move.b	d4,3(a1,d5)
		lsl	#5,d4
		move.b	(a2,d6),(a0,d4)
		bsr	SortStringNow
		move	StringNow,d4
		move.b	d4,2(a1,d5)
		lsl	#5,d4
		move.b	1(a2,d6),(a0,d4)
		bra	Norm1ToStr

OnCaps		subq	#1,d0
		moveq	#0,d1
		lea	MapToKeys,a0
		move.b	(a0,d0),d1
		lea	CapsTab,a1
		eori.b	#1,(a1,d1)		; Toggle value in table
		bra	CheckMessage

OnRept		subq	#1,d0
		moveq	#0,d1
		lea	MapToKeys,a0
		move.b	(a0,d0),d1
		lea	ReptTab,a1
		eori.b	#1,(a1,d1)
		bra	CheckMessage

AnalyseKM	bsr	ClearOut

		clr.b	ModifyIndex		; Reset counter
		move.l	MySegment,d0
		lsl.l	#2,d0
		addi.l	#18,d0
		move.l	d0,a2
		move.l	km_LoCapsable(a2),a0	; First extract caps
		lea	CapsTab,a1
		moveq	#0,d1
		moveq	#0,d3
AnlCapLp	move.b	(a0,d3),d0
		bsr	Anly_Bit
		addq	#1,d3
		cmpi	#8,d3
		bne	AnlCapLp
		move.l	km_HiCapsable(a2),a0	; Now high caps
		moveq	#0,d3
AnlCapLpHi	move.b	(a0,d3),d0
		bsr	Anly_Bit
		addq	#1,d3
		cmpi	#4,d3
		bne	AnlCapLpHi

		move.l	km_LoRepeatable(a2),a0	; Now extract repeaters
		lea	ReptTab,a1
		moveq	#0,d1
		moveq	#0,d3
AnlRepLp	move.b	(a0,d3),d0
		bsr	Anly_Bit
		addq	#1,d3
		cmpi	#8,d3
		bne	AnlRepLp
		move.l	km_HiRepeatable(a2),a0
		moveq	#0,d3
AnlRepLpHi	move.b	(a0,d3),d0
		bsr	Anly_Bit
		addq	#1,d3
		cmpi	#4,d3
		bne	AnlRepLpHi

		move.l	km_LoKeyMapTypes(a2),a0	; Get key types
		lea	KeyTypes,a1
		moveq	#$3e,d0
KTypeLp		move	(a0,d0),(a1,d0)
		tst	d0
		beq.s	KTypeLoOver
		subq	#2,d0
		bra	KTypeLp

KTypeLoOver	move.l	km_HiKeyMapTypes(a2),a0
		moveq	#$1e,d0
KTypeHi		move	(a0,d0),$40(a1,d0)
		tst	d0
		beq.s	KTypeOver
		subq	#2,d0
		bra	KTypeHi

KTypeOver	move.l	km_LoKeyMap(a2),a0	; Now for the actual keys!
		lea	KeyDefs,a1
		move	#252,d0
ActKeyLp	move.l	(a0,d0),(a1,d0)
		tst	d0
		beq.s	ActKeyLoOvr
		subq	#4,d0
		bra	ActKeyLp

ActKeyLoOvr	move.l	km_HiKeyMap(a2),a0
		adda.l	#$100,a1
		move	#$7c,d0
ActKeyHi	move.l	(a0,d0),(a1,d0)
		tst	d0
		beq.s	ActKeyOvr
		subq	#4,d0
		bra	ActKeyHi

ActKeyOvr	lea	KeyTypes,a0		; Get deadkeys
		lea	KeyDefs,a1
		lea	DeadTab,a3
		moveq	#0,d0
DeadLoop	move.b	(a0,d0),d1
		andi.b	#KCF_DEAD,d1
		beq.s	NotDead

		move	d0,d2			; Get dead key descriptor
		lsl	#2,d2
		move.l	(a1,d2),a2
		lsl	#2,d2
		movea.l	a2,a6
		moveq	#0,d7
DeadLoop2	move.b	(a2),(a3,d2)
		move.b	1(a2),1(a3,d2)
		bsr	IndexSub
		adda.l	#2,a2
		addq	#2,d2
		addq	#2,d7
		cmpi	#16,d7
		bne	DeadLoop2

NotDead		addq	#1,d0
		cmpi	#96,d0
		bne	DeadLoop

		lea	DeadTab,a4		; Check deads
		lea	KeyTypes,a0
		moveq	#0,d0
		moveq	#0,d4
SortDeadLp	move.b	(a0,d0),d1
		andi.b	#KCF_DEAD,d1
		cmpi.b	#KCF_DEAD,d1
		bne.s	ContDChk
		bsr	DeadToVan
ContDChk	addq	#1,d0
		addi	#16,d4
		cmpi.b	#96,d0
		bne	SortDeadLp

		clr.l	UseDead
		clr.l	UseDead+4
		clr.l	UseDead+8
		clr.l	UseDead+12

		lea	DeadTab,a0		; Count no. of deadkeys
		lea	UseDead,a1		; and modkeys
		lea	ModIndex,a2
		moveq	#0,d0
		moveq	#0,d1
UseDeadLp	move.b	(a0,d0),d1		; Get key data
		cmpi.b	#DPF_DEAD,d1		; Is it a deadkey?
		beq.s	Dead_D			; Yes, so branch
		cmpi.b	#DPF_MOD,d1		; Is it modifiable?
		beq.s	Dead_M

NotCounted	addq	#2,d0
		cmpi	#768*2,d0		; Have we finished?
		bne	UseDeadLp
		bra	ExString

Dead_D		move.b	1(a0,d0),d1		; Get significant byte
		andi.b	#$0f,d1			; Avoid double-deadkeys
		move.b	#1,(a1,d1)		; Mark as in use
		bra	NotCounted

Dead_M		move.b	1(a0,d0),d1		; Mark modifiable as
		move.b	#1,(a2,d1)		; in use
		bra	NotCounted

Anly_Bit	moveq	#0,d2			; Extract nos. from the
Anly_BLp	btst	#0,d0			; bit table
		beq.s	BitLow
		move.b	#1,(a1,d1)
		bra.s	EBLp
BitLow		clr.b	(a1,d1)
EBLp		lsr.b	d0
		addi	#1,d2
		addi	#1,d1
		cmpi	#8,d2
		bne	Anly_BLp
		rts

IndexSub	cmpi.b	#DPF_MOD,(a2)		; Subroutine to extract data
		bne.s	NotIndex		; for keys of type DPF_MOD

		movea.l	a6,a4			; Only 256 DPF_MODs allowed!
		moveq	#0,d3
		move.b	1(a2),d3
		add.l	d3,a4
		move.b	ModifyIndex,d3
		mulu	#16,d3
		moveq	#0,d4
		lea	DeadIndex,a5
IndexLoop	move.b	(a4,d4),(a5,d3)
		move.b	1(a4,d4),1(a5,d3)
		cmpi	#14,d4
		beq.s	IndexOver
		addq	#2,d3
		addq	#2,d4
		bra	IndexLoop

IndexOver	move.b	ModifyIndex,1(a3,d2)
		addq.b	#1,ModifyIndex
NotIndex	rts

ExString	move.l	MySegment,d0		; Get strings
		lsl.l	#2,d0
		addi.l	#18,d0
		move.l	d0,a0
		move.l	km_LoKeyMap(a0),a0
		lea	KeyTypes,a1
		moveq	#0,d0
		moveq	#0,d3
StrLoop		move.b	(a1,d0),d1
		andi.b	#KCF_STRING,d1
		beq	NotStr

		move.b	(a1,d0),d1
		andi.b	#KC_VANILLA,d1
		bne.s	.1
		clr	d2
		bra.s	.index
.1		cmpi.b	#KC_VANILLA,d1
		bne.s	.2
		move	#14,d2
		bra.s	.index
.2		cmpi.b	#KCF_SHIFT,d1
		bne.s	.3
		move	#2,d2
		bra.s	.index
.3		cmpi.b	#KCF_ALT,d1
		bne.s	.4
		move	#2,d2
		bra.s	.index
.4		cmpi.b	#KCF_CONTROL,d1
		bne.s	.5
		move	#2,d2
		bra.s	.index
.5		move	#6,d2

.index		move.l	(a0,d3),a2		; Get string descriptor
		lea	StringList,a3
		lea	StringArea,a4

GetStrLoop	lsr	#1,d2
		move	StringNow,d5		; Show where string is
		lsl	#3,d0
		add	d0,d2
		move.b	d5,(a3,d2)
		sub	d0,d2
		lsr	#3,d0
		lsl	#1,d2
		lsl	#5,d5			; d5 = Pos in StringArea
		move.b	(a2,d2),d6		; d6 = String length
		tst.b	d6
		beq.s	FinGotStr
		cmpi.b	#31,d6
		bcs.s	.okay
		move.b	#31,d6
		moveq	#0,d7
.okay		move.b	1(a2,d2),d7		; Get string location
		move	d5,-(sp)		; Save d5
GetString	move.b	(a2,d7),(a4,d5)		; Get string from keymap
		cmpi.b	#1,d6
		beq.s	GotString

		addq	#1,d7
		addq	#1,d5
		subq	#1,d6
		bra	GetString

GotString	clr.b	1(a4,d5)
		bsr.s	SortStringNow
		move	(sp)+,d5		; Restore d5
FinGotStr	tst	d2
		beq.s	NotStr

		subq	#2,d2
		bra	GetStrLoop

NotStr		addq	#1,d0
		addq	#4,d3
		cmpi.b	#$60,d0
		beq.s	EndStr
		cmpi.b	#$40,d0
		bne	StrLoop
		move	d0,-(sp)
		move.l	MySegment,d0
		lsl.l	#2,d0
		addi.l	#18,d0
		move.l	d0,a0
		move	(sp)+,d0
		move.l	km_HiKeyMap(a0),a0	; Switch to high keymap
		moveq	#0,d3
		bra	StrLoop

EndStr		move.l	MySegment,d1		; Unload keymap
		CALLDOS	UnLoadSeg		; and finish routine
		rts

SortStringNow	move.l	d7,-(sp)		; Finds a free string
		lea	StringArea,a5		; a5 scratch
		moveq	#0,d7
SortLoop	tst.b	(a5,d7)
		beq.s	SoGotOne
		addi	#32,d7
		cmpi	#8192,d7
		bne	SortLoop
		move	#$100,StringNow
		bra.s	ResSort
SoGotOne	lsr	#5,d7
		clr.b	StringNow
		move.b	d7,StringNow+1
ResSort		move.l	(sp)+,d7
		rts

QuitProper	move.l	Windowhd,a0		; Requester to check if
		lea	ReqText,a1		; you really want to quit
		lea	LReqText,a2
		lea	RReqText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#255,d2
		moveq	#53,d3
		CALLINT	AutoRequest

		tst.l	d0
		beq	CheckMessage
		moveq	#RETURN_OK,d5
		move.l	Windowhd,a0		; Tidy up and exit
		CALLINT	ClearMenuStrip
_NoMenus	move.l	Windowhd,a0
		CALLINT	CloseWindow
_NoRun		move.l	_GfxBase,a1
		CALLEXEC CloseLibrary
_NoGraphics	move.l	_DOSBase,a1
		CALLEXEC CloseLibrary
_NoArp		move.l	_IntuitionBase,a1
		CALLEXEC CloseLibrary

		movea.l	AslFReq,a0
		cmpa.l	#0,a0
		beq.s	AslError1
		movea.l	_AslBase,a6
		CALLSYS	FreeFileRequest
AslError1	move.l	_AslBase,a1
		cmpa.l	#0,a1
		beq.s	AslError2
		CALLEXEC CloseLibrary
AslError2	rts				; Au revoir, mes amis!!

NoMenus		moveq	#RETURN_FAIL,d5		; DOS error codes
		bra	_NoMenus
NoRun	moveq	#RETURN_FAIL,d5
		bra	_NoRun
NoGraphics	moveq	#RETURN_FAIL,d5
		bra	_NoGraphics
NoArp		moveq	#RETURN_FAIL,d5
		bra	_NoArp
NoIntuition	moveq	#RETURN_FAIL,d5
		rts

NoArpLib	suba.l	a0,a0
		lea	NoArpErr,a1
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#312,d2
		moveq	#83,d3
		CALLINT	AutoRequest
		bra	NoArp

WindSetUp	move.l	d0,a0
		move.l	wd_UserPort(a0),UserPort
		move.l	wd_RPort(a0),RPort
		rts

ClearOut	lea	CapsTab,a0
		moveq	#96,d0
		bsr.s	ClearIt
		lea	ReptTab,a0
		moveq	#96,d0
		bsr.s	ClearIt
		lea	KeyTypes,a0
		bsr.s	ClearIt2
		lea	UseDead,a0
		moveq	#16,d0
		bsr.s	ClearIt
		lea	ModIndex,a0
		move	#256,d0
		bsr.s	ClearIt
		lea	StringList,a0
		move	#768,d0
		bsr.s	ClearIt
		lea	DeadTab,a0
		move	#768*2,d0
		bsr.s	ClearIt
		lea	KeyDefs,a0
		move	#96*4,d0
		bsr.s	ClearIt
		lea	StringArea,a0
		move	#8192,d0
		bsr.s	ClearIt
		clr.b	DeadNo
		clr.b	ModNo
		bra	SortStringNow

ClearIt		subq	#1,d0
ClearLoop	clr.b	(a0,d0)
		tst	d0
		beq.s	ClearStop
		subq	#1,d0
		bra	ClearLoop
ClearStop	rts

ClearIt2	moveq	#95,d0
.loop		move.b	#KCF_NOP,(a0,d0)
		tst	d0
		beq.s	.stop
		subq	#1,d0
		bra	.loop
.stop		rts

ARP_Extract	lea	PathName,a0		; Extract dir...
		movea.l	xFile,a1
		movea.l	xDir,a2
ARP_xLp		move.b	(a2)+,(a0)+
		bne	ARP_xLp
		lea	PathName,a0
		bsr	_TackOn
		lea	PathName,a0
		moveq	#0,d5
ARP_xLp2	tst.b	(a0,d5)
		beq.s	ARP_xLp3
		addq	#1,d5
		cmpi.b	#72,d5
		bne	ARP_xLp2
ARP_xLp3	rts

LoadKeyMap	moveq	#0,d6			; Needs PathLength in d5,
		move.l	#PathName,d1		; returns d6=0 ok
		CALLDOS	LoadSeg
		move.l	d0,MySegment
		beq.s	DskError		; Problem so exit...

		bsr	TestKeyMap		; Check integrity
		cmpi	#2,d6
		bne.s	AddNames
		rts

AddNames	lea	ModWindText-1,a3
AddName		move.b	(a2,d5),d2
		tst.b	d2
		bne.s	NoStopMod
		bra.s	StopMod

NoStopMod	move.b	d2,1(a3,d1)
		addq	#1,d5
		addq	#1,d1
		cmpi	#8,d1
		bne	AddName

StopMod		move.b	#"»",1(a3,d1)
		clr.b	2(a3,d1)
		tst.l	Windowhd
		beq.s	StopModF
		move.l	Windowhd,a0
		move.l	#%0000000001000000,d0
		CALLINT	OnMenu
		move.l	Windowhd,a0
		lea	MainWindowText,a1
		move.l	#-1,a2
		CALLSYS	SetWindowTitles
StopModF	rts

DskError	cmpi.b	#1,ErrResponse
		beq.s	WBDskErr
		cmpi.b	#2,ErrResponse
		beq.s	EndDskErr
		tst.l	ReturnMsg
		bne.s	WBDskErr

		CALLDOS	Output			; Write out error message
		move.l	d0,d4
		move.l	d4,d1
		move.l	#FileErr1,d2
		move.l	#FileErr1End-FileErr1,d3
		CALLSYS	Write
		move.l	d4,d1
		move.l	#PathName,d2
		moveq	#0,d3
		move	d5,d3
		CALLSYS	Write
		move.l	d4,d1
		move.l	#FileErr2,d2
		move.l	#FileErr2End-FileErr2,d3
		CALLSYS	Write
		bra.s	EndDskErr

WBDskErr	suba.l	a0,a0
		lea	WBNoFile,a1		; 'No File' requester
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#350,d2
		moveq	#62,d3
		CALLINT	AutoRequest
EndDskErr	moveq	#1,d6
		rts

TestKeyMap	move.l	d5,d7
		moveq	#0,d3
		lsl.l	#2,d0
		move.l	d0,a0
		adda.l	#14,a0
		move.l	(a0),a0

		subq	#1,d5			; Get keymap name
		moveq	#0,d1
		lea	PathName,a2
GetKeyName	move.b	(a2,d5),d0
		cmpi.b	#"/",d0
		beq.s	Got1Name
		cmpi.b	#":",d0
		beq.s	Got1Name
		tst	d5
		beq.s	GotName
		subq	#1,d5
		bra	GetKeyName

Got1Name	addq	#1,d5
GotName		move	d5,-(sp)		; Save d5
GotNameLp	move.b	(a2,d5),d2
		cmp.b	(a0,d3),d2
		bne.s	EndName
		addq	#1,d5
		tst.b	(a0,d3)
		beq	ItsOver
		addq	#1,d3
		bra	GotNameLp

EndName		moveq	#2,d6
		cmpi.b	#1,ErrResponse
		beq.s	WBFault
		cmpi.b	#2,ErrResponse
		beq.s	ItsOver
		tst.l	ReturnMsg
		bne.s	WBFault

		CALLDOS	Output			; Write out error message
		move.l	d0,d4
		move.l	d4,d1
		move.l	#IntgErr1,d2
		move.l	#IntgErr1End-IntgErr1,d3
		CALLSYS	Write
		move.l	d4,d1
		move.l	#PathName,d2
		moveq	#0,d3
		move	d7,d3
		CALLSYS	Write
		move.l	d4,d1
		move.l	#IntgErr2,d2
		move.l	#IntgErr2End-IntgErr2,d3
		CALLSYS	Write
		bra.s	ItsOver

WBFault		suba.l	a0,a0
		lea	WBFaultFile,a1		; 'Incorrect File' requester
		suba.l	a2,a2
		lea	AbortText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#342,d2
		moveq	#62,d3
		CALLINT	AutoRequest
ItsOver		move	(sp)+,d5		; Recover d5
		rts

CheckQual	tst.b	ChQVal
		beq.s	NormCQual
		moveq	#0,d0
		move.b	MyDefQual,d0
		rts

NormCQual	moveq	#0,d0			; Which qualifiers are
		move	Gadg89+gg_Flags,d1	; currently active?
		andi	#SELECTED,d1
		beq.s	CheckShift
		addq	#1,d0
CheckShift	move	Gadg90+gg_Flags,d1
		andi	#SELECTED,d1
		beq.s	CheckAlt
		addq	#2,d0
CheckAlt	move	Gadg92+gg_Flags,d1
		andi	#SELECTED,d1
		beq.s	ChecksOver
		addq	#4,d0
ChecksOver	rts

GenerateKeys	bsr	CheckQual
		lsl	#2,d0
		lea	QualTable,a0
		move.l	(a0,d0),NoDeadStore
		lea	DQualTab,a0
		move.l	(a0,d0),DeadStore

		lea	IDtoGadget,a0
		lea	KeyTypes,a2
		lea	KeyDefs,a3
		lea	CodetoImage,a4
		lea	MapToKeys,a5
		moveq	#0,d0
		moveq	#0,d1

GenKeyLoop	move.l	(a0,d0),a1		; Gadget address in a1
		cmpa.l	#0,a1			; Should we change the image?
		beq.s	NotThisOne

		moveq	#0,d2
		move.b	(a5,d1),d2		; Keycode in d2

		move.b	(a2,d2),d3		; Get key type
		andi.b	#KCF_STRING,d3
		bne.s	NoGrafStr
		moveq	#0,d3
		move.b	(a2,d2),d3
		andi.b	#KCF_DEAD,d3
		bne.s	GenDead
		move.b	(a2,d2),d3
		cmpi.b	#KCF_NOP,d3
		beq.s	NoGraf
		andi.b	#KC_VANILLA,d3		; Find which key in each
		moveq	#0,d6			; key definition list
		move.l	NoDeadStore,a6
		move.b	(a6,d3),d6		; Get index
		cmpi.b	#-1,d6			; Is it invalid?
		beq.s	NoGraf

		moveq	#0,d5			; Extract key from the
		move.b	d2,d3			; 'KeyDefs' table
		lsl	#2,d3
		sub	d6,d3
		move.b	3(a3,d3),d4		; ASCII value in d4
DeadASC		cmpi.b	#32,d4			; Is it <SPACE
		bcs.s	NoGraf

		subi.b	#32,d4
		moveq	#0,d5
		move.b	d4,d5
		lsl	#2,d5
		move.l	(a4,d5),d6		; Image address in d2
		move.l	d6,gg_GadgetRender(a1)	; Phew!

NotThisOne	addq	#4,d0
		addq	#1,d1
		cmpi	#88,d1
		bne	GenKeyLoop
		rts

NoGrafStr	move.l	#StrIm,gg_GadgetRender(a1)
		bra	NotThisOne

NoGraf		move.l	#A20,gg_GadgetRender(a1)
		bra	NotThisOne

GenDead		move.b	(a2,d2),d3
		andi.b	#KC_VANILLA,d3
		move.l	DeadStore,a6
		moveq	#0,d7
		move.b	(a6,d3),d7		; Get index
		move.l	a0,d6
		lea	DeadTab,a0
		move	d2,d5
		lsl	#4,d5
		add	d7,d5
		move.b	(a0,d5),d2
		tst.b	d2
		beq.s	CanDoDead
		cmpi.b	#DPF_MOD,d2
		beq.s	ModDead
		move.l	d6,a0
		bra	NoGraf

CanDoDead	move.b	1(a0,d5),d4
		move.l	d6,a0
		bra	DeadASC

ModDead		moveq	#0,d2
		move.b	1(a0,d5),d2
		mulu	#16,d2
		lea	DeadIndex,a0
		move.b	(a0,d2),d4
		move.l	d6,a0
		bra	DeadASC

RedrawKeys	move.l	Windowhd,a0		; Redo all the keys eg
		lea	StrGadg,a1		; after qualifier change
		moveq	#89,d0
		CALLINT	RemoveGList
		bra	GenerateKeys

ERedrawKeys	move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	StrGadg,a0
		move.l	Windowhd,a1
		moveq	#89,d0
		CALLSYS	RefreshGList
		rts

PickUpDead	moveq	#0,d0			; Pick out all dead keys
		moveq	#0,d1
		lea	DeadIDtoGadg,a0
		lea	KeyTypes,a2
		lea	MapToKeys,a5

DeadKeyLoop	move.l	(a0,d0),a1
		moveq	#0,d2
		move.b	(a5,d1),d2
		moveq	#0,d3
		move.b	(a2,d2),d3
		andi.b	#KCF_DEAD,d3		; Is it KCF_DEAD?
		beq.s	FinDeadLoop

		move.b	(a2,d2),d3
		andi.b	#KC_VANILLA,d3
		move.l	DeadStore,a6
		moveq	#0,d7
		move.b	(a6,d3),d7
		lea	DeadTab,a4
		move	d2,d5
		lsl	#4,d5
		add	d7,d5
		move.b	(a4,d5),d2
		cmp.b	DeadByte,d2
		bne.s	FinDeadLoop
		move	On_Value,gg_Flags(a1)

FinDeadLoop	addq	#4,d0
		addq	#1,d1
		cmpi	#88,d1
		bne	DeadKeyLoop
		rts

SetUpKeyOn	bsr	CheckQual
		cmp.b	MyDefQual,d0
		beq.s	ItsThisOne
ItsVeryEarly	move	#GADGHCOMP!GADGDISABLED,StrGadg+gg_Flags
		bra	CSIoff

ItsThisOne	tst.l	MyDefKey
		beq	ItsVeryEarly
		move.l	MyDefKey,a0
		move	gg_Flags(a0),d0
		andi	#GADGDISABLED,d0
		bne.s	NewFirst
		move	gg_Flags(a0),d0
		eori	#SELECTED,d0
		move	d0,gg_Flags(a0)
		move	#GADGHCOMP,StrGadg+gg_Flags
		bra	CSIon

NewFirst	clr.l	MyDefKey
		bra	ItsVeryEarly

ActString	cmpi	#GADGHCOMP,StrGadg+gg_Flags
		beq.s	StringOn
		rts

StringOn	lea	StrGadg,a0		; If gadget not disabled
		move.l	Windowhd,a1		; then activate it...
		suba.l	a2,a2
		CALLINT	ActivateGadget
		rts

OnDead		lea	KeyTypes,a0
		lea	CheckTab,a2
		lea	MapToKeys,a3
		lea	DeadTab,a4

		subq	#1,d0
		move.b	d0,MD_GadgNo
		moveq	#0,d2
		moveq	#0,d4
		move.b	(a3,d0),d4
		move.b	d4,MD_KeyType		; Store for later

		move.b	(a0,d4),d3
		bsr	CheckQual
		moveq	#0,d2
		move.b	(a2,d0),d2		; Get offset into key
		lsl	#4,d4
		move	d4,MD_DeadTab		; Store for later
		add	d4,d2			; d2 hold key address
		move	d2,MD_DTbPos

		andi.b	#KCF_DEAD,d3		; Is this a deadkey?
		beq	MakeNewDead

		cmpi.b	#DPF_DEAD,(a4,d2)	; Is this key dead?
		beq	TurnDeadOff

		moveq	#7,d0
DeadChLp	move.b	(a4,d4),d2		; Is there a dead on this
		cmpi.b	#DPF_DEAD,d2		; physical key?
		beq.s	FoundXDead		; Yes
		addq	#2,d4
		dbeq	d0,DeadChLp

		moveq	#0,d4
		move.b	MD_KeyType,d4
		bsr	NewDeadIndex
		bsr.s	CommonDead
		bra	MakeOldDead

FoundXDead	move	d4,OldDeadOff
		move.l	Windowhd,a0
		lea	DeadQuest,a1
		lea	LReqText,a2
		lea	RReqText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#445,d2
		moveq	#62,d3
		CALLINT	AutoRequest

		lea	KeyTypes,a0		; Restore pointers
		lea	CheckTab,a2
		lea	MapToKeys,a3
		moveq	#0,d4
		move.b	MD_KeyType,d4

		tst	d0
		bne.s	UseOldDead
		bsr	NewDeadIndex
		bsr.s	CommonDead
		bra.s	MakeOldDead

UseOldDead	move	OldDeadOff,d6
		move.b	1(a4,d6),MD_Index	; Store old deadkey
		bsr.s	CommonDead
		bra.s	MakeOldDead

CommonDead	moveq	#0,d4
		move.b	MD_KeyType,d4
		move.b	(a0,d4),d6
		andi.b	#KC_VANILLA,d6

		move	MD_DeadTab,d4
		move	MD_DTbPos,d2
		rts

MakeNewDead	bsr	CommonDead
		clr.l	(a4,d4)			; Clear out deadkey
		clr.l	4(a4,d4)
		clr.l	8(a4,d4)
		clr.l	12(a4,d4)

		bsr	NewDeadIndex
		moveq	#0,d0
		move.b	MD_KeyType,d0
		bsr	NormToDead

MakeOldDead	move.b	#DPF_DEAD,(a4,d2)	; Create dead
		move.b	MD_Index,1(a4,d2)	; Store its index

DeadRedraw	move.l	Windowhd,a0		; Redraw affected key
		lea	StrGadg,a1
		moveq	#89,d0
		CALLINT	RemoveGList
		bsr	GenerateKeys
		bsr	NoOfDead
		move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	DeadIDtoGadg,a0
		moveq	#0,d0
		move.b	MD_GadgNo,d0
		lsl	#2,d0
		move.l	(a0,d0),a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList

		cmpi.b	#1,d7
		bne.s	CheckReturn
		lea	Gadg01,a0
		move.l	Windowhd,a1
		moveq	#88,d0
		CALLSYS	RefreshGList

CheckReturn	cmpi.b	#45,MD_GadgNo
		bne	CheckMessage
		lea	Gadg87,a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList
		bra	CheckMessage

NewDeadIndex	lea	UseDead,a5		; Get a new index for
		moveq	#1,d0			; deadkey
NDIndLoop	tst.b	(a5,d0)
		beq.s	GotNewIndex
		addq	#1,d0
		cmpi.b	#16,d0
		bne	NDIndLoop
		addq.l	#4,a7			; None available
		bra	CheckMessage

GotNewIndex	move.b	#1,(a5,d0)
		move.b	d0,MD_Index		; Store and return
		rts

NormToDead	lea	DeadTab,a4		; d4 holds index in DeadTab
		lea	KeyDefs,a5		; d5 = d4 ÷ 4
		move	d4,d5			; d6 holds qualifiers
		lsr	#2,d5

		move.b	3(a5,d5),1(a4,d4)	; Store NOQUAL
		cmpi.b	#KC_NOQUAL,d6		; Is that all?
		beq.s	ENtoD

		move.b	2(a5,d5),3(a4,d4)
		cmpi.b	#KCF_SHIFT,d6
		beq.s	ENtoD
		cmpi.b	#KCF_ALT,d6
		beq.s	ENtoD
		cmpi.b	#KCF_CONTROL,d6
		beq.s	ENtoD

		move.b	1(a5,d5),5(a4,d4)
		move.b	(a5,d5),7(a4,d4)
		cmpi.b	#KC_VANILLA,d6
		bne.s	ENtoD

		move.l	(a4,d4),8(a4,d4)	; Do VANILLA ctrl keys
		move.l	4(a4,d4),12(a4,d4)
		andi.b	#%10011111,9(a4,d4)
		andi.b	#%10011111,11(a4,d4)
		andi.b	#%10011111,13(a4,d4)
		andi.b	#%10011111,15(a4,d4)

ENtoD		clr.l	(a5,d5)			; Clear old table
		bsr	DeadToVan		; Sort out dead
		rts

TurnDeadOff	move	MD_DTbPos,d2
		moveq	#0,d7
		move.b	1(a4,d2),d7		; Store deadkey index
		andi.b	#$0f,d7
		clr	(a4,d2)			; Clear out deadkey

		moveq	#0,d6
TurnDLoop	cmpi.b	#DPF_DEAD,(a4,d6)	; Is this dead index
		bne.s	TNotDead		; used elsewhere?
		move.b	1(a4,d6),d5
		andi.b	#$0f,d5
		cmp.b	d5,d7
		beq.s	TDeadUsed
TNotDead	addq	#2,d6
		cmpi	#768*2,d6
		bne	TurnDLoop

		lea	UseDead,a5
		clr.b	(a5,d7)			; Clear out old index

TDeadUsed	lea	KeyTypes,a3
		move	d4,d3
		lsr	#4,d3
		moveq	#7,d0

TDeadChLp	move.b	(a4,d4),d2
		cmpi.b	#DPF_DEAD,d2
		beq	DCheckNo
		cmpi.b	#DPF_MOD,d2
		beq	DCheckNo
		addq	#2,d4
		dbeq	d0,TDeadChLp
		move	MD_DeadTab,d4

		bsr	D_VanTest
		tst.b	d0
		bne	LoseSome

DeadToNorm	move	d4,d5			; This routine expects
		lsr	#2,d5			; as input a deadkey in
		lea	KeyDefs,a5		; (a4,d4) (Not KC_VANILLA)
		clr.l	(a5,d5)			; which it compresses as
		andi.b	#KC_VANILLA,(a3,d3)	; much as is possible

		cmpi.b	#KC_NOQUAL,(a3,d3)
		beq	DN_DZero
		cmpi.b	#KCF_SHIFT,(a3,d3)	; What is the key size?
		beq	DN_One
		cmpi.b	#KCF_ALT,(a3,d3)
		beq	DN_One
		cmpi.b	#KCF_CONTROL,(a3,d3)
		beq	DN_One

		tst.b	3(a4,d4)
		beq.s	DN_TwoA
		tst.b	5(a4,d4)
		beq.s	DN_TwoB
		move.b	3(a4,d4),d0
		move.b	1(a4,d4),d1
		cmp.b	d0,d1
		beq.s	DN_TwoC
		move.b	5(a4,d4),d0
		cmp.b	d0,d1
		beq.s	DN_TwoD
		bra	DN_DTwo

DN_TwoA		tst.b	7(a4,d4)
		bne.s	DN_DTwo
		move	4(a4,d4),2(a4,d4)
		bra.s	DN_Two_Rem3

DN_TwoB		tst.b	7(a4,d4)
		bne.s	DN_DTwo
		bra.s	DN_Two_Rem5

DN_TwoC		move.b	7(a4,d4),d0
		move.b	5(a4,d4),d1
		cmp.b	d0,d1
		bne.s	DN_DTwo
		move	4(a4,d4),2(a4,d4)
		bra.s	DN_Two_Rem3

DN_TwoD		move.b	7(a4,d4),d0
		move.b	3(a4,d4),d0
		cmp.b	d0,d1
		bne.s	DN_DTwo
		bra.s	DN_Two_Rem5

DN_Two_Rem3	cmpi.b	#KCF_ALT+KCF_SHIFT,(a3,d3)
		beq.s	DN_Two_R3a
		move.b	#KCF_CONTROL,(a3,d3)
		bra.s	DN_One
DN_Two_R3a	move.b	#KCF_ALT,(a3,d3)
		bra.s	DN_One

DN_Two_Rem5	cmpi.b	#KCF_ALT+KCF_CONTROL,(a3,d3)
		beq.s	DN_Two_R5a
		move.b	#KCF_SHIFT,(a3,d3)
		bra.s	DN_One
DN_Two_R5a	move.b	#KCF_ALT,(a3,d3)

DN_One		move.b	3(a4,d4),d1
		tst.b	d1
		beq.s	DN_OneA
		move.b	1(a4,d4),d0
		cmp.b	d0,d1
		bne.s	DN_DOne
DN_OneA		move.b	#KC_NOQUAL,(a3,d3)
		bra.s	DN_DZero

DN_DTwo		move.b	7(a4,d4),(a5,d5)	; Transfer from DeadTab
		move.b	5(a4,d4),1(a5,d5)	; to KeyDefs
DN_DOne		move.b	3(a4,d4),2(a5,d5)
DN_DZero	move.b	1(a4,d4),3(a5,d5)

		clr.l	(a4,d4)
		clr.l	4(a4,d4)
		clr.l	8(a4,d4)
		clr.l	12(a4,d4)

		cmpi.b	#KCF_SHIFT,(a3,d3)
		beq.s	DoVanTest
		cmpi.b	#KCF_ALT,(a3,d3)
		beq.s	DoVanTest
		cmpi.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		beq.s	DoVanTest
		bra	DCheckNo

DoVanTest	move.l	Windowhd,a0		; What should we do
		lea	VanText,a1		; about CTRL key?
		lea	VanPos,a2
		move.l	a3,-(sp)		; Save a3
		lea	VanNeg,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#397,d2
		move	d3,-(sp)		; Save d3
		moveq	#62,d3
		CALLINT	AutoRequest
		move	(sp)+,d3
		move.l	(sp)+,a3
		tst.l	d0
		beq	DCheckNo
		cmpi.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		beq.s	VanTest
		move	2(a5,d5),(a5,d5)	; Change type to VANILLA
VanTest		move.b	#KC_VANILLA,(a3,d3)
		bra	DCheckNo

LoseSome	bsr	DoLoseReq
		tst.b	d0			; Should we abort?
		beq	DLStop

		cmpi.b	#1,d0			; Now act on the users
		beq.s	DL_S			; prompt in the requester
		cmpi.b	#2,d0
		beq.s	DL_A
		cmpi.b	#3,d0
		beq.s	DL_SA
		cmpi.b	#4,d0
		beq.s	DL_C
		cmpi.b	#5,d0
		beq.s	DL_SC
		cmpi.b	#6,d0
		beq.s	DL_AC

		move.b	#KC_NOQUAL,(a3,d3)
		bra	DeadToNorm
DL_AC		move.b	#KCF_SHIFT,(a3,d3)
		bra	DeadToNorm
DL_SC		move.b	#KCF_ALT,(a3,d3)
		move	4(a4,d4),2(a4,d4)
		bra	DeadToNorm
DL_C		move.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		bra	DeadToNorm
DL_SA		move.b	#KCF_CONTROL,(a3,d3)
		move	8(a4,d4),2(a4,d4)
		bra	DeadToNorm
DL_A		move.b	#KCF_SHIFT+KCF_CONTROL,(a3,d3)
		move.l	8(a4,d4),4(a4,d4)
		bra	DeadToNorm
DL_S		move.b	#KCF_ALT+KCF_CONTROL,(a3,d3)
		move	4(a4,d4),2(a4,d4)
		move	8(a4,d4),4(a4,d4)
		move	12(a4,d4),6(a4,d4)
		bra	DeadToNorm

DLStop		move	MD_DTbPos,d2		; Repair deadkey
		move.b	#DPF_DEAD,(a4,d2)
		move.b	d7,1(a4,d2)
		move.b	#1,(a5,d7)
		lea	DeadIDtoGadg,a0
		moveq	#0,d0
		move.b	MD_GadgNo,d0
		lsl	#2,d0
		move.l	(a0,d0),a0
		ori	#SELECTED,gg_Flags(a0)
		bra	DeadRedraw

DoLoseReq	lea	LoseReq,a0
		move.l	Windowhd,a1
		CALLINT	Request

DLMLoop		move.l	UserPort,a0		; Wait for an Intuition
		CALLEXEC WaitPort		; message...
DLChkMsg	move.l	UserPort,a0
		CALLEXEC GetMsg
		tst.l	d0
		beq	DLMLoop
		move.l	d0,a1
		move.l	im_Class(a1),d2
		move.l	im_IAddress(a1),a2
		CALLSYS	ReplyMsg
		cmpi.l	#GADGETUP,d2
		beq.s	DLGadgBit
		bra	DLChkMsg

DLGadgBit	move	gg_GadgetID(a2),d0	; Which gadget was it?
		cmpi	#4,d0
		beq.s	DLReqOver1
		cmpi	#5,d0
		beq	DLReqOver2

		cmpi	#GADGHCOMP!SELECTED!GADGIMAGE,LsGadg1+gg_Flags
		beq.s	DLG_Fin
		cmpi	#GADGHCOMP!SELECTED,LsGadg2+gg_Flags
		beq.s	DLG_Fin
		cmpi	#GADGHCOMP!SELECTED,LsGadg3+gg_Flags
		beq.s	DLG_Fin
		lea	LsGadg4,a0
		move.l	Windowhd,a1
		lea	LoseReq,a2
		move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,LsGadg4+gg_Flags
		bra.s	DLG_Fin2

DLG_Fin		move	#GADGHCOMP!GADGIMAGE,LsGadg4+gg_Flags

DLG_Fin2	lea	LsGadg4,a0
		move.l	Windowhd,a1
		lea	LoseReq,a2
		moveq	#1,d0
		CALLINT	RefreshGList
		bra	DLChkMsg

DLReqOver1	clr.b	d0
		cmpi	#GADGHCOMP!GADGIMAGE,LsGadg1+gg_Flags
		beq.s	DLReq1
		addq.b	#2,d0
DLReq1		cmpi	#GADGHCOMP,LsGadg2+gg_Flags
		beq.s	DLReq2
		addq.b	#4,d0
DLReq2		cmpi	#GADGHCOMP,LsGadg3+gg_Flags
		beq.s	DLReq3
		addq.b	#1,d0
DLReq3		rts

DLReqOver2	clr.b	d0
		rts

DCheckNo	tst.b	DeadNo			; Have we freed the
		beq	DeadRedraw		; only available dead?
		clr.b	DeadNo
		lea	UseDead,a0
		cmpi.l	#$00010101,(a0)
		bne.s	DCheckPos
		cmpi.l	#$01010101,4(a0)
		bne.s	DCheckPos
		cmpi.l	#$01010101,8(a0)
		bne.s	DCheckPos
		cmpi.l	#$01010101,12(a0)
		bne.s	DCheckPos
		move.b	#1,DeadNo
		bra	DeadRedraw

DCheckPos	bsr	GenerateKeys
		bra	GGadge

D_VanTest	move.b	1(a4,d4),d0		; Can we remove CTRL?
		move.b	9(a4,d4),d1
		tst.b	d0
		beq.s	D_VC1
		tst.b	d1
		beq.s	D_VC1
		cmp.b	d0,d1
		bne.s	D_VATest
D_VC1		move.b	3(a4,d4),d0
		move.b	11(a4,d4),d1
		tst.b	d0
		beq.s	D_VC2
		tst.b	d1
		beq.s	D_VC2
		cmp.b	d0,d1
		bne.s	D_VATest
D_VC2		move.b	5(a4,d4),d0
		move.b	13(a4,d4),d1
		tst.b	d0
		beq.s	D_VC3
		tst.b	d1
		beq.s	D_VC3
		cmp.b	d0,d1
		bne.s	D_VATest
D_VC3		move.b	7(a4,d4),d0
		move.b	15(a4,d4),d1
		tst.b	d0
		beq.s	D_VC4
		tst.b	d1
		beq.s	D_VC4
		cmp.b	d0,d1
		bne.s	D_VATest
D_VC4		tst.b	1(a4,d4)
		bne.s	D_VC5
		move.b	9(a4,d4),1(a4,d4)
D_VC5		tst.b	3(a4,d4)
		bne.s	D_VC6
		move.b	11(a4,d4),3(a4,d4)
D_VC6		tst.b	5(a4,d4)
		bne.s	D_VC7
		move.b	13(a4,d4),5(a4,d4)
D_VC7		tst.b	7(a4,d4)
		bne.s	D_VC8
		move.b	15(a4,d4),7(a4,d4)
D_VC8		move.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		clr.b	d0
		rts

D_VATest	move.b	5(a4,d4),d0		; Can we remove ALT?
		move.b	1(a4,d4),d1
		tst.b	d0
		beq.s	D_VA1
		tst.b	d1
		beq.s	D_VA1
		cmp.b	d0,d1
		bne	D_VSTest
D_VA1		move.b	7(a4,d4),d0
		move.b	3(a4,d4),d1
		tst.b	d0
		beq.s	D_VA2
		tst.b	d1
		beq.s	D_VA2
		cmp.b	d0,d1
		bne.s	D_VSTest
D_VA2		move.b	13(a4,d4),d0
		move.b	9(a4,d4),d1
		tst.b	d0
		beq.s	D_VA3
		tst.b	d1
		beq.s	D_VA3
		cmp.b	d0,d1
		bne.s	D_VSTest
D_VA3		move.b	15(a4,d4),d0
		move.b	11(a4,d4),d1
		tst.b	d0
		beq.s	D_VA4
		tst.b	d1
		beq.s	D_VA4
		cmp.b	d0,d1
		bne.s	D_VSTest
D_VA4		tst.b	5(a4,d4)
		bne.s	D_VA5
		move.b	5(a4,d4),1(a4,d4)
D_VA5		tst.b	3(a4,d4)
		bne.s	D_VA6
		move.b	7(a4,d4),3(a4,d4)
D_VA6		tst.b	9(a4,d4)
		bne.s	D_VA7
		move.b	13(a4,d4),9(a4,d4)
D_VA7		move.b	9(a4,d4),5(a4,d4)
		tst.b	11(a4,d4)
		bne.s	D_VA8
		move.b	15(a4,d4),11(a4,d4)
D_VA8		move.b	11(a4,d4),7(a4,d4)
		move.b	#KCF_SHIFT+KCF_CONTROL,(a3,d3)
		clr.b	d0
		rts

D_VSTest	move.b	3(a4,d4),d0		; Can we remove SHIFT?
		move.b	1(a4,d4),d1
		tst.b	d0
		beq.s	D_VS1
		tst.b	d1
		beq.s	D_VS1
		cmp.b	d0,d1
		bne	D_VEnd
D_VS1		move.b	7(a4,d4),d0
		move.b	5(a4,d4),d1
		tst.b	d0
		beq.s	D_VS2
		tst.b	d1
		beq.s	D_VS2
		cmp.b	d0,d1
		bne.s	D_VEnd
D_VS2		move.b	11(a4,d4),d0
		move.b	9(a4,d4),d1
		tst.b	d0
		beq.s	D_VS3
		tst.b	d1
		beq.s	D_VS3
		cmp.b	d0,d1
		bne.s	D_VEnd
D_VS3		move.b	15(a4,d4),d0
		move.b	13(a4,d4),d1
		tst.b	d0
		beq.s	D_VS4
		tst.b	d1
		beq.s	D_VS4
		cmp.b	d0,d1
		bne.s	D_VEnd
D_VS4		tst.b	3(a4,d4)
		bne.s	D_VS5
		move.b	3(a4,d4),1(a4,d4)
D_VS5		tst.b	5(a4,d4)
		bne.s	D_VS6
		move.b	7(a4,d4),5(a4,d4)
D_VS6		move.b	5(a4,d4),3(a4,d4)
		tst.b	9(a4,d4)
		bne.s	D_VS7
		move.b	11(a4,d4),9(a4,d4)
D_VS7		move.b	9(a4,d4),5(a4,d4)
		tst.b	13(a4,d4)
		bne.s	D_VS8
		move.b	15(a4,d4),13(a4,d4)
D_VS8		move.b	13(a4,d4),7(a4,d4)
		move.b	#KCF_ALT+KCF_CONTROL,(a3,d3)
		clr.b	d0
		rts

D_VEnd		move.b	-1,d0
		rts

DeadToVan	move.b	(a0,d0),d6		; Expands deadkey to
		andi.b	#KC_VANILLA,d6		; KC_VANILLA. (a4,d4) holds
		cmpi.b	#KC_NOQUAL,d6		; key, (a0,d0) keytype
		beq	DV_NQual
		cmpi.b	#KCF_SHIFT,d6
		beq	DV_S
		cmpi.b	#KCF_ALT,d6
		beq	DV_A
		cmpi.b	#KCF_CONTROL,d6
		beq.s	DV_C
		cmpi.b	#KCF_SHIFT+KCF_ALT,d6
		beq.s	DV_SA
		cmpi.b	#KCF_SHIFT+KCF_CONTROL,d6
		beq.s	DV_SC
		cmpi.b	#KCF_CONTROL+KCF_ALT,d6
		bne	DV_Final

		move	6(a4,d4),12(a4,d4)
		move	4(a4,d4),8(a4,d4)
		move	2(a4,d4),4(a4,d4)
		move	(a4,d4),2(a4,d4)
		move	4(a4,d4),6(a4,d4)
		move	8(a4,d4),10(a4,d4)
		move	12(a4,d4),12(a4,d4)
		bra	DV_Final

DV_SC		move.l	4(a4,d4),8(a4,d4)
		move.l	(a4,d4),4(a4,d4)
		move.l	8(a4,d4),12(a4,d4)
		bra.s	DV_Final

DV_SA		move.l	(a4,d4),8(a4,d4)
		move.l	4(a4,d4),12(a4,d4)
		bra.s	DV_Final

DV_C		move	2(a4,d4),8(a4,d4)
		move	(a4,d4),2(a4,d4)
		move.l	(a4,d4),4(a4,d4)
		move	8(a4,d4),10(a4,d4)
		move.l	8(a4,d4),12(a4,d4)
		bra.s	DV_Final

DV_A		move	2(a4,d4),4(a4,d4)
		move	(a4,d4),2(a4,d4)
		move	4(a4,d4),6(a4,d4)
		move.l	(a4,d4),8(a4,d4)
		move.l	4(a4,d4),12(a4,d4)
		bra.s	DV_Final

DV_S		move.l	(a4,d4),4(a4,d4)
		move.l	(a4,d4),8(a4,d4)
		move.l	(a4,d4),12(a4,d4)
		bra.s	DV_Final

DV_NQual	move	(a4,d4),2(a4,d4)
		move.l	(a4,d4),4(a4,d4)
		move.l	(a4,d4),8(a4,d4)
		move.l	(a4,d4),12(a4,d4)

DV_Final	move.b	#KCF_DEAD+KC_VANILLA,(a0,d0)
		rts

CancelString	moveq	#0,d0
		lea	KeyTypes,a0
		lea	KeysToMap,a1
CStrLoop	move.b	(a0,d0),d1
		andi.b	#KCF_STRING,d1
		tst.b	d1
		bne.s	CancelStr
StrDone		addq	#1,d0
		cmpi.b	#96,d0
		bne	CStrLoop
		rts

CancelStr	move	d0,d1
		lsl	#2,d1
		move.l	(a1,d1),a2
		cmpa.l	#0,a2
		beq	StrDone
		move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,gg_Flags(a2)
		bra	StrDone

NoOfDead	moveq	#0,d7			; d7 holds returncode
		lea	UseDead,a0
		cmpi.l	#$00010101,(a0)
		bne.s	NotAllDead
		cmpi.l	#$01010101,4(a0)
		bne.s	NotAllDead
		cmpi.l	#$01010101,8(a0)
		bne.s	NotAllDead
		cmpi.l	#$01010101,12(a0)
		bne.s	NotAllDead

		moveq	#0,d0
		lea	KeysToMap,a0
NDeadLoop	move.l	(a0,d0),a1
		cmpa.l	#0,a1
		beq.s	NotCancelDead

		cmpi	#GADGHCOMP!GADGIMAGE!SELECTED,gg_Flags(a1)
		beq.s	NotCancelDead
		move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,gg_Flags(a1)

NotCancelDead	addq	#4,d0
		cmpi	#4*96,d0
		bne	NDeadLoop
		move.b	#1,d7
		move.b	#1,DeadNo
NotAllDead	rts

OnMod		lea	KeyTypes,a0
		lea	CheckTab,a2
		lea	MapToKeys,a3
		lea	DeadTab,a4

		subq	#1,d0
		move.b	d0,MD_GadgNo
		moveq	#0,d2
		moveq	#0,d4
		move.b	(a3,d0),d4
		move.b	d4,MD_KeyType		; Store for later

		move.b	(a0,d4),d3
		bsr	CheckQual
		moveq	#0,d2
		move.b	(a2,d0),d2		; Get offset into key
		lsl	#4,d4
		move	d4,MD_DeadTab		; Store for later
		add	d4,d2			; d2 hold key address
		move	d2,MD_DTbPos

		andi.b	#KCF_DEAD,d3		; Is this a deadkey?
		beq.s	MakeNewMod

		cmpi.b	#DPF_MOD,(a4,d2)	; Is this key deadable?
		beq	TurnModOff

		bsr	NewModIndex		; This is a physical key
		bsr.s	CommonMod		; deadkey already
		bra.s	MakeOldMod

CommonMod	moveq	#0,d4
		move.b	MD_KeyType,d4
		move.b	(a0,d4),d6
		andi.b	#KC_VANILLA,d6
		move	MD_DeadTab,d4
		move	MD_DTbPos,d2
		rts

MakeNewMod	bsr	CommonMod
		clr.l	(a4,d4)			; Clear out deadkey
		clr.l	4(a4,d4)
		clr.l	8(a4,d4)
		clr.l	12(a4,d4)

		bsr.s	NewModIndex
		moveq	#0,d0
		move.b	MD_KeyType,d0
		bsr	NormToDead

MakeOldMod	lea	DeadIndex,a0
		moveq	#0,d0
		move.b	MD_Index,d0
		lsl	#4,d0
		move.b	1(a4,d2),(a0,d0)	; Start modkey
		move.b	(a0,d0),1(a0,d0)
		move	(a0,d0),2(a0,d0)
		move.l	(a0,d0),4(a0,d0)
		move.l	(a0,d0),8(a0,d0)
		move.l	(a0,d0),12(a0,d0)
		move.b	#DPF_MOD,(a4,d2)	; Create mod
		move.b	MD_Index,1(a4,d2)	; Store its index
		bra	ModRedraw		; Redraw affected key

NewModIndex	lea	ModIndex,a5		; Get a new index for
		moveq	#0,d0			; modkey
NMIndLoop	tst.b	(a5,d0)
		beq	GotNewIndex
		addq	#1,d0
		cmpi	#256,d0
		bne	NMIndLoop
		addq.l	#4,a7			; None available
		bra	CheckMessage

TurnModOff	move	MD_DTbPos,d2
		moveq	#0,d7
		move.b	1(a4,d2),d7		; Store modkey index
		clr.b	(a4,d2)			; Clear out modkey

		lea	DeadIndex,a3
		moveq	#0,d6
		move.b	d7,d6
		lsl	#4,d6
		move.b	(a3,d6),1(a4,d2)	; Replace key value

		moveq	#0,d6
TurnMLoop	cmpi.b	#DPF_MOD,(a4,d6)	; Is this dead index
		bne.s	TNotMod			; used elsewhere?
		move.b	1(a4,d6),d5
		cmp.b	d5,d7
		beq.s	TModUsed
TNotMod		addq	#2,d6
		cmpi	#768*2,d6
		bne	TurnMLoop

		lea	ModIndex,a5
		clr.b	(a5,d7)			; Clear out old index

TModUsed	lea	KeyTypes,a3
		move	d4,d3
		lsr	#4,d3
		moveq	#7,d0

TModChLp	move.b	(a4,d4),d2
		cmpi.b	#DPF_DEAD,d2
		beq	MCheckNo
		cmpi.b	#DPF_MOD,d2
		beq	MCheckNo
		addq	#2,d4
		dbeq	d0,TModChLp
		move	MD_DeadTab,d4

		bsr	D_VanTest
		tst.b	d0
		bne	M_LoseSome

ModToNorm	move	d4,d5			; This routine expects
		lsr	#2,d5			; as input a deadkey in
		lea	KeyDefs,a5		; (a4,d4) (Not KC_VANILLA)
		clr.l	(a5,d5)			; which it compresses as
		andi.b	#KC_VANILLA,(a3,d3)	; much as is possible

		cmpi.b	#KC_NOQUAL,(a3,d3)
		beq	MN_DZero
		cmpi.b	#KCF_SHIFT,(a3,d3)	; What is the key size?
		beq	MN_One
		cmpi.b	#KCF_ALT,(a3,d3)
		beq	MN_One
		cmpi.b	#KCF_CONTROL,(a3,d3)
		beq	MN_One

		tst.b	3(a4,d4)
		beq.s	MN_TwoA
		tst.b	5(a4,d4)
		beq.s	MN_TwoB
		move.b	3(a4,d4),d0
		move.b	1(a4,d4),d1
		cmp.b	d0,d1
		beq.s	MN_TwoC
		move.b	5(a4,d4),d0
		cmp.b	d0,d1
		beq.s	MN_TwoD
		bra	MN_DTwo

MN_TwoA		tst.b	7(a4,d4)
		bne.s	MN_DTwo
		move	4(a4,d4),2(a4,d4)
		bra.s	MN_Two_Rem3

MN_TwoB		tst.b	7(a4,d4)
		bne.s	MN_DTwo
		bra.s	MN_Two_Rem5

MN_TwoC		move.b	7(a4,d4),d0
		move.b	5(a4,d4),d1
		cmp.b	d0,d1
		bne.s	MN_DTwo
		move	4(a4,d4),2(a4,d4)
		bra.s	MN_Two_Rem3

MN_TwoD		move.b	7(a4,d4),d0
		move.b	3(a4,d4),d0
		cmp.b	d0,d1
		bne.s	MN_DTwo
		bra.s	MN_Two_Rem5

MN_Two_Rem3	cmpi.b	#KCF_ALT+KCF_SHIFT,(a3,d3)
		beq.s	MN_Two_R3a
		move.b	#KCF_CONTROL,(a3,d3)
		bra.s	MN_One
MN_Two_R3a	move.b	#KCF_ALT,(a3,d3)
		bra.s	MN_One

MN_Two_Rem5	cmpi.b	#KCF_ALT+KCF_CONTROL,(a3,d3)
		beq.s	MN_Two_R5a
		move.b	#KCF_SHIFT,(a3,d3)
		bra.s	MN_One
MN_Two_R5a	move.b	#KCF_ALT,(a3,d3)

MN_One		move.b	3(a4,d4),d1
		tst.b	d1
		beq.s	MN_OneA
		move.b	1(a4,d4),d0
		cmp.b	d0,d1
		bne.s	MN_DOne
MN_OneA		move.b	#KC_NOQUAL,(a3,d3)
		bra.s	MN_DZero

MN_DTwo		move.b	7(a4,d4),(a5,d5)	; Transfer from DeadTab
		move.b	5(a4,d4),1(a5,d5)	; to KeyDefs
MN_DOne		move.b	3(a4,d4),2(a5,d5)
MN_DZero	move.b	1(a4,d4),3(a5,d5)

		clr.l	(a4,d4)
		clr.l	4(a4,d4)
		clr.l	8(a4,d4)
		clr.l	12(a4,d4)

		cmpi.b	#KCF_SHIFT,(a3,d3)
		beq.s	M_DoVanTest
		cmpi.b	#KCF_ALT,(a3,d3)
		beq.s	M_DoVanTest
		cmpi.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		beq.s	M_DoVanTest
		bra	MCheckNo

M_DoVanTest	move.l	Windowhd,a0		; What should we do
		lea	VanText,a1		; about CTRL key?
		lea	VanPos,a2
		move.l	a3,-(sp)		; Save a3
		lea	VanNeg,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#397,d2
		move	d3,-(sp)		; Save d3
		moveq	#62,d3
		CALLINT	AutoRequest
		move	(sp)+,d3
		move.l	(sp)+,a3
		tst.l	d0
		beq	MCheckNo
		cmpi.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		beq.s	M_VanTest
		move	2(a5,d5),(a5,d5)	; Change type to VANILLA
M_VanTest	move.b	#KC_VANILLA,(a3,d3)
		bra	MCheckNo

M_LoseSome	bsr	DoLoseReq
		tst.b	d0			; Should we abort?
		beq	MLStop

		cmpi.b	#1,d0			; Now act on the users
		beq.s	ML_S			; prompt in the requester
		cmpi.b	#2,d0
		beq.s	ML_A
		cmpi.b	#3,d0
		beq.s	ML_SA
		cmpi.b	#4,d0
		beq.s	ML_C
		cmpi.b	#5,d0
		beq.s	ML_SC
		cmpi.b	#6,d0
		beq.s	ML_AC

		move.b	#KC_NOQUAL,(a3,d3)
		bra	ModToNorm
ML_AC		move.b	#KCF_SHIFT,(a3,d3)
		bra	ModToNorm
ML_SC		move.b	#KCF_ALT,(a3,d3)
		move	4(a4,d4),2(a4,d4)
		bra	ModToNorm
ML_C		move.b	#KCF_SHIFT+KCF_ALT,(a3,d3)
		bra	ModToNorm
ML_SA		move.b	#KCF_CONTROL,(a3,d3)
		move	8(a4,d4),2(a4,d4)
		bra	ModToNorm
ML_A		move.b	#KCF_SHIFT+KCF_CONTROL,(a3,d3)
		move.l	8(a4,d4),4(a4,d4)
		bra	ModToNorm
ML_S		move.b	#KCF_ALT+KCF_CONTROL,(a3,d3)
		move	4(a4,d4),2(a4,d4)
		move	8(a4,d4),4(a4,d4)
		move	12(a4,d4),6(a4,d4)
		bra	ModToNorm

MLStop		move	MD_DTbPos,d2		; Repair deadkey
		move.b	#DPF_MOD,(a4,d2)
		move.b	d7,1(a4,d2)
		move.b	#1,(a5,d7)
		lea	DeadIDtoGadg,a0
		moveq	#0,d0
		move.b	MD_GadgNo,d0
		lsl	#2,d0
		move.l	(a0,d0),a0
		ori	#SELECTED,gg_Flags(a0)
		bra.s	ModRedraw

MCheckNo	tst.b	ModNo			; Have we freed the
		beq.s	ModRedraw		; only available mod?
		clr.b	ModNo

		lea	ModIndex,a0
		moveq	#0,d0
MC_Loop		cmpi.b	#1,(a0,d0)
		bne.s	MCheckPos
		addq	#1,d0
		cmpi	#256,d0
		bne	MC_Loop
		move.b	#1,ModNo
		bra.s	ModRedraw

MCheckPos	bsr	GenerateKeys
		bra	GGadgd

ModRedraw	move.l	Windowhd,a0		; Redraw affected key
		lea	StrGadg,a1
		moveq	#89,d0
		CALLINT	RemoveGList
		bsr	GenerateKeys
		bsr.s	NoOfMod
		move.l	Windowhd,a0
		lea	StrGadg,a1
		moveq	#5,d0
		moveq	#89,d1
		CALLINT	AddGList

		lea	DeadIDtoGadg,a0
		moveq	#0,d0
		move.b	MD_GadgNo,d0
		lsl	#2,d0
		move.l	(a0,d0),a0
		move.l	Windowhd,a1
		moveq	#1,d0
		CALLSYS	RefreshGList

		cmpi.b	#1,d7
		bne	CheckReturn
		lea	Gadg01,a0
		move.l	Windowhd,a1
		moveq	#88,d0
		CALLSYS	RefreshGList
		bra	CheckReturn

NoOfMod		moveq	#0,d7			; d7 holds returncode
		lea	ModIndex,a0
		moveq	#0,d0
NoOfMod_1	cmpi.b	#1,(a0,d0)
		bne	NotAllDead
		addq	#1,d0
		cmpi	#256,d0
		bne	NoOfMod_1

		moveq	#0,d0
		lea	KeysToMap,a0
NModLoop	move.l	(a0,d0),a1
		cmpa.l	#0,a1
		beq.s	NotCancelMod

		cmpi	#GADGHCOMP!GADGIMAGE!SELECTED,gg_Flags(a1)
		beq.s	NotCancelMod
		move	#GADGHCOMP!GADGIMAGE!GADGDISABLED,gg_Flags(a1)

NotCancelMod	addq	#4,d0
		cmpi	#4*96,d0
		bne	NModLoop
		move.b	#1,d7
		move.b	#1,ModNo
		rts

ChangeKString	bsr	CheckQual		; Should we alter the
		cmp.b	MyDefQual,d0		; key in the small square?
		bne.s	ChangeKOver

		move	MyNewKey,d7
		tst	d7
		beq.s	ChangeKOver
		bra	KeyInString
ChangeKOver	rts

ReqStart	cmpi.b	#1,MyMode
		bne	CheckMessage
		move.l	DeadTxt,DDeadTxt
		move.l	DeadTxt+4,DDeadTxt+4
		move.b	CurrDKey,DCurrDKey
		bra.s	DMChkMsg

DMLoop		move.l	UserPort,a0		; Wait for an Intuition
		CALLEXEC WaitPort		; message...
DMChkMsg	move.l	UserPort,a0
		CALLEXEC GetMsg
		tst.l	d0
		beq	DMLoop
		move.l	d0,a1
		move.l	im_Class(a1),d2
		move	im_Code(a1),d3
		move	im_Qualifier(a1),d4
		move.l	im_IAddress(a1),a2
		CALLSYS	ReplyMsg
		cmpi.l	#RAWKEY,d2
		beq	DMKey
		cmpi.l	#GADGETUP,d2
		beq.s	DMGadg
		bra	DMChkMsg

DMGadg		cmpi	#1,gg_GadgetID(a2)
		beq.s	DMEndIt
		cmpi	#2,gg_GadgetID(a2)
		beq.s	DMQuit
		cmpi	#3,gg_GadgetID(a2)
		beq.s	DMClear
		bra	DMChkMsg

DMEndIt		move.l	DDeadTxt,DeadTxt
		move.l	DDeadTxt+4,DeadTxt+4
		move.b	DCurrDKey,CurrDKey

DMQuit		move.l	DeadTxt,DblGTxt4
		move.l	DeadTxt+4,DblGTxt4+4
		move.l	LastQualVal,d0
		move.l	LastGadgVal,d7
		cmpi.l	#-1,d7
		bne.s	DMDoSKey
		bsr	KI_NoKey
		bra	CheckMessage
DMDoSKey	bsr	KeyInString2
		bra	CheckMessage

DMClear		move.l	#$20202020,DblGTxt4
		move.l	#$20202000,DblGTxt4+4
		lea	DblGadg4,a0
		move.l	Windowhd,a1
		lea	DoubleReq,a2
		moveq	#1,d0
		CALLINT	RefreshGList

		clr.b	DCurrDKey
		move.l	#$20202020,DDeadTxt
		move.l	#$20202000,DDeadTxt+4
		bra	DMChkMsg

DMKey		cmpi.b	#$60,d3
		bcc	DMChkMsg

		move.l	#$2020202d,DblGTxt4
		move.l	#$20202000,DblGTxt4+4

		lea	KeyTypes,a0
		move.b	(a0,d3),d0		; Is key KCF_DEAD?
		andi.b	#KCF_DEAD,d0
		beq	DMNotDead

		moveq	#0,d0			; Analyse qualifiers
		moveq	#0,d7
		move.b	d4,d0
		andi.b	#IEQUALIFIER_LSHIFT,d0
		beq.s	DMKey2
		bsr	DMShift
DMKey2		move.b	d4,d0
		andi.b	#IEQUALIFIER_RSHIFT,d0
		beq.s	DMKey3
		bsr	DMShift
DMKey3		move.b	d4,d0
		andi.b	#IEQUALIFIER_CONTROL,d0
		beq.s	DMKey4
		bsr	DMControl
DMKey4		move.b	d4,d0
		andi.b	#IEQUALIFIER_LALT,d0
		beq.s	DMKey5
		bsr	DMAlt
DMKey5		move.b	d4,d0
		andi.b	#IEQUALIFIER_RALT,d0
		beq.s	DMKey6
		bsr	DMAlt

DMKey6		lea	KeyTab1,a0		; Analyse key - is it
		moveq	#0,d0			; a special one?
DMKLoop1	cmp.b	(a0,d0),d3
		beq.s	DMGotOne
		addq	#1,d0
		cmpi.b	#KeyTab1End-KeyTab1,d0
		bne	DMKLoop1

		moveq	#0,d0			; Process normal key
		move.b	d3,d0
		lsl	#4,d0
		move	d0,d1
		addi	#16,d1
		lea	DeadTab,a0
DMKLoop2	tst.b	(a0,d0)
		beq.s	DMGotDef
		cmpi.b	#DPF_MOD,(a0,d0)
		beq.s	DMGotDef2
		addq	#2,d0
		cmp	d0,d1
		bne	DMKLoop2
		move.b	#" ",DblGTxt4+4
		bra.s	DMAllProc

DMGotDef	move.b	1(a0,d0),DblGTxt4+4
		bra.s	DMAllProc

DMGotDef2	moveq	#0,d1
		move.b	1(a0,d0),d1
		lsl	#4,d1
		lea	DeadIndex,a1
		move.b	(a1,d1),DblGTxt4+4
		bra.s	DMAllProc

DMGotOne	mulu	#3,d0			; Get text for key
		lea	KeyTab2,a0
		move.b	(a0,d0),DblGTxt4+4
		move.b	1(a0,d0),DblGTxt4+5
		move.b	2(a0,d0),DblGTxt4+6

DMAllProc	moveq	#0,d0			; Search for deadkey
		move.b	d3,d0
		lsl	#4,d0
		add	d7,d0
		lea	DeadTab,a0
		cmpi.b	#DPF_DEAD,(a0,d0)
		bne	DMNotDead

DMGotDead	move.b	1(a0,d0),DCurrDKey
		andi.b	#$0f,DCurrDKey
		cmpi.b	#" ",DblGTxt4+2
		bne.s	DMG_1
		bsr.s	DM_Tract2
		bra	DMGotDead
DMG_1		cmpi.b	#" ",DblGTxt4+1
		bne.s	DMG_2
		bsr.s	DM_Tract1
		bra	DMG_1
DMG_2		cmpi.b	#" ",DblGTxt4
		bne.s	DM_TDone
		bsr.s	DM_Tract
		bra	DMG_2

DM_TDone	cmpi.b	#"-",DblGTxt4
		bne.s	DM_T2
		bsr.s	DM_Tract

DM_T2		lea	DblGadg4,a0
		move.l	Windowhd,a1
		lea	DoubleReq,a2
		moveq	#1,d0
		CALLINT	RefreshGList

		move.l	DblGTxt4,DDeadTxt	; Store new key
		move.l	DblGTxt4+4,DDeadTxt+4
		bra	DMChkMsg

DM_Tract	move.b	DblGTxt4+1,DblGTxt4
DM_Tract1	move.b	DblGTxt4+2,DblGTxt4+1
DM_Tract2	move.b	DblGTxt4+3,DblGTxt4+2
		move.b	DblGTxt4+4,DblGTxt4+3
		move.b	DblGTxt4+5,DblGTxt4+4
		move.b	DblGTxt4+6,DblGTxt4+5
		move.b	#" ",DblGTxt4+6
		rts

DMShift		move.b	#"S",DblGTxt4
		ori	#2,d7
		rts
DMAlt		move.b	#"A",DblGTxt4+1
		ori	#4,d7
		rts
DMControl	move.b	#"C",DblGTxt4+2
		ori	#8,d7
		rts

DMNotDead	suba.l	a0,a0
		CALLINT	DisplayBeep
		bra	DMChkMsg

CopyToSave	lea	PathName,a0		; Store a pathname we
		lea	SavePath,a1		; might need later...
CopyLoop	move.l	(a0)+,(a1)+
		cmpa.l	#PathName+72,a0
		bne	CopyLoop
		rts

Sisters		tst.b	SisTst
		beq.s	SisGo
		rts

SisGo		move.b	#1,SisTst
		move.l	Windowhd,a0
		lea	SoM1,a1
		suba.l	a2,a2
		lea	LucText,a3
		moveq	#0,d0
		moveq	#0,d1
		move	#386,d2
		move	#90,d3
		CALLINT	AutoRequest
		rts

StrComp		moveq	#0,d0			; Compare two strings in a
		moveq	#0,d1			; case sensitive way
StrCLoop	move.b	(a0,d0),d2		; a0 & a1 hold strings...
		cmp.b	(a1,d1),d2
		bne.s	StrNeg
		tst.b	d2
		beq.s	StrPos
		addq	#1,d0
		addq	#1,d1
		bra	StrCLoop
StrPos		moveq	#0,d0
		rts
StrNeg		moveq	#1,d0
		rts

CSIon		lea	CSIGadg,a0
		move.l	Windowhd,a1
		suba.l	a2,a2
		CALLINT	OnGadget
		rts

CSIoff		lea	CSIGadg,a0
		move.l	Windowhd,a1
		suba.l	a2,a2
		CALLINT	OffGadget
		rts

_TackOn		moveq	#0,d0
		moveq	#0,d1
		tst.b	(a0)
		beq.s	.copy
.loop		tst.b	(a0,d0)
		beq.s	.out
		addq	#1,d0
		bra	.loop
.out		cmpi.b	#":",-1(a0,d0)
		beq.s	.copy
		cmpi.b	#"/",-1(a0,d0)
		beq.s	.copy
		move.b	#"/",(a0,d0)
		addq	#1,d0

.copy		move.b	(a1,d1),(a0,d0)
		beq.s	.over
		addq	#1,d0
		addq	#1,d1
		bra	.copy
.over		rts

_GADS		tst.b	OS2
		bne.s	.new
		lea	Par_Help,a1
		lea	Par_Arry,a2
		lea	Par_Temp,a3
		CALLDOS	GADS
		move.l	d0,d7
		rts

.new		move.l	#Par_Temp,d1
		move.l	#Par_Arry,d2
		move.l	#OS2Args,d3
		CALLDOS	ReadArgs
		CALLSYS	IoErr
		move.l	d0,d7
		bne.s	.errover

		move.l	Par_Arry,a0
		cmpa.l	#0,a0
		beq.s	.noover
		tst.b	(a0)
		beq.s	.noover
		moveq	#1,d7
		bra.s	.over

.errover	neg.l	d7
		bra.s	.over
.noover		moveq	#0,d7
.over		move.l	#OS2Args,d1
		CALLSYS	FreeArgs
		rts

		section	Data,data

OS2Args		dc.l	0,0,0,0,0,0,Par_Help,0

MainWindow	dc.w	0,0,592,128
		dc.b	0,1
		dc.l	MENUPICK!GADGETDOWN!GADGETUP!REQSET!RAWKEY!CLOSEWINDOW
		dc.l	WINDOWDRAG!WINDOWDEPTH!WINDOWCLOSE!ACTIVATE
		dc.l	0,0,MainWindowText,0,0
		dc.w	0,0,0,0,WBENCHSCREEN
MainWindowText	dc.b	"EditKeys v1.2 «"
ModWindText	dc.b	"»",0,0,0,0,0,0,0
EndWindText	dc.b	0,0

Gadg0a		dc.l	Gadg0b
		dc.w	31,95,90,11
		dc.w	GADGHCOMP!GADGIMAGE!SELECTED,GADGIMMEDIATE,BOOLGADGET
		dc.l	Imagea,0,0,0,0
		dc.w	-1
		dc.l	0

Gadg0b		dc.l	Gadg0c
		dc.w	141,95,90,11
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Imageb,0,0,0,0
		dc.w	-2
		dc.l	0

Gadg0c		dc.l	Gadg0d
		dc.w	251,95,90,11
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Imagec,0,0,0,0
		dc.w	-3
		dc.l	0

Gadg0d		dc.l	Gadg0e
		dc.w	361,95,90,11
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Imaged,0,0,0,0
		dc.w	-4
		dc.l	0

Gadg0e		dc.l	StrGadg
		dc.w	471,95,90,11
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Imagee,0,0,0,0
		dc.w	-5
		dc.l	0

StrGadg		dc.l	Gadg01
		dc.w	192,113,248,8
		dc.w	GADGHCOMP!GADGDISABLED,RELVERIFY
		dc.w	STRGADGET
		dc.l	0,0,0,0,SpecialInfo
		dc.w	0
		dc.l	0

StrBord1	dc.w	188,111
		dc.b	1,0,0,6
		dc.l	StrAry1,StrBord2
StrAry1		dc.w	0,11,0,0,254,0,254,11,1,11,1,0

StrBord2	dc.w	188,111
		dc.b	1,0,0,2
		dc.l	StrAry2,0
StrAry2		dc.w	255,0,255,11

SpecialInfo	dc.l	StringBuf,0
		dc.w	0,32,0,0,0,0,0,0
		dc.l	0
		dc.l	0,0

GadgMac		MACRO				; This gadget, next gadget,
Gadg\1		dc.l	Gadg\2			; x pos, y pos, image
		dc.w	\3,\4,24,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	\5,0,0,0,0
		dc.w	\1
		dc.l	0
		ENDM

		GadgMac	01,02,12,16,Image01

Gadg02		dc.l	Gadg03
		dc.w	44,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If1,0,0,0,0
		dc.w	2
		dc.l	0

Gadg03		dc.l	Gadg04
		dc.w	76,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If2,0,0,0,0
		dc.w	3
		dc.l	0

Gadg04		dc.l	Gadg05
		dc.w	108,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If3,0,0,0,0
		dc.w	4
		dc.l	0

Gadg05		dc.l	Gadg06
		dc.w	140,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If4,0,0,0,0
		dc.w	5
		dc.l	0

Gadg06		dc.l	Gadg07
		dc.w	172,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If5,0,0,0,0
		dc.w	6
		dc.l	0

Gadg07		dc.l	Gadg08
		dc.w	211,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If6,0,0,0,0
		dc.w	7
		dc.l	0

Gadg08		dc.l	Gadg09
		dc.w	243,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If7,0,0,0,0
		dc.w	8
		dc.l	0

Gadg09		dc.l	Gadg10
		dc.w	275,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If8,0,0,0,0
		dc.w	9
		dc.l	0

Gadg10		dc.l	Gadg11
		dc.w	307,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If9,0,0,0,0
		dc.w	10
		dc.l	0

Gadg11		dc.l	Gadg12
		dc.w	339,16,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	If0,0,0,0,0
		dc.w	11
		dc.l	0

Gadg12		dc.l	Gadg13
		dc.w	12,31,31,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Itl,0,0,0,0
		dc.w	12
		dc.l	0

		GadgMac	13,14,44,31,A20
		GadgMac	14,15,69,31,A20
		GadgMac	15,16,94,31,A20
		GadgMac	16,17,119,31,A20
		GadgMac	17,18,144,31,A20
		GadgMac	18,19,169,31,A20
		GadgMac	19,20,194,31,A20
		GadgMac	20,21,219,31,A20
		GadgMac	21,22,244,31,A20
		GadgMac	22,23,269,31,A20
		GadgMac	23,24,294,31,A20
		GadgMac	24,25,319,31,A20
		GadgMac	25,26,344,31,A20
		GadgMac	26,27,369,31,Image02

Gadg27		dc.l	Gadg28
		dc.w	406,31,30,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Image03,0,0,0,0
		dc.w	27
		dc.l	0

Gadg28		dc.l	Gadg29
		dc.w	437,31,30,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Image04,0,0,0,0
		dc.w	28
		dc.l	0

		GadgMac	29,30,481,31,A20
		GadgMac	30,31,506,31,A20
		GadgMac	31,32,531,31,A20
		GadgMac	32,33,556,31,A20

Gadg33		dc.l	Gadg34
		dc.w	12,42,44,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Image05,0,0,0,0
		dc.w	33
		dc.l	0

		GadgMac	34,35,57,42,A20
		GadgMac	35,36,82,42,A20
		GadgMac	36,37,107,42,A20
		GadgMac	37,38,132,42,A20
		GadgMac	38,39,157,42,A20
		GadgMac	39,40,182,42,A20
		GadgMac	40,41,207,42,A20
		GadgMac	41,42,232,42,A20
		GadgMac	42,43,257,42,A20
		GadgMac	43,44,282,42,A20
		GadgMac	44,45,307,42,A20
		GadgMac	45,47,332,42,A20
		GadgMac	47,48,481,42,A20
		GadgMac	48,49,506,42,A20
		GadgMac	49,50,531,42,A20
		GadgMac	50,51,556,42,A20
		GadgMac	51,52,64,53,A20
		GadgMac	52,53,89,53,A20
		GadgMac	53,54,114,53,A20
		GadgMac	54,55,139,53,A20
		GadgMac	55,56,164,53,A20
		GadgMac	56,57,189,53,A20
		GadgMac	57,58,214,53,A20
		GadgMac	58,59,239,53,A20
		GadgMac	59,60,264,53,A20
		GadgMac	60,61,289,53,A20
		GadgMac	61,87,314,53,A20
		GadgMac	87,46,339,53,A20

Gadg46		dc.l	Gadg62
		dc.w	357,42,36,21
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!BOOLEXTEND,BOOLGADGET
		dc.l	Image07,0,0,0,Spec46
		dc.w	46
		dc.l	0

Spec46		dc.w	BOOLMASK
		dc.l	Mask46,0

		GadgMac	62,63,425,53,Image08
		GadgMac	63,64,481,53,A20
		GadgMac	64,65,506,53,A20
		GadgMac	65,66,531,53,A20
		GadgMac	66,88,556,53,A20
		GadgMac	88,67,53,64,A20
		GadgMac	67,68,78,64,A20
		GadgMac	68,69,103,64,A20
		GadgMac	69,70,128,64,A20
		GadgMac	70,71,153,64,A20
		GadgMac	71,72,178,64,A20
		GadgMac	72,73,203,64,A20
		GadgMac	73,74,228,64,A20
		GadgMac	74,75,253,64,A20
		GadgMac	75,76,278,64,A20
		GadgMac	76,77,303,64,A20
		GadgMac	77,78,400,64,Image02
		GadgMac	78,79,425,64,Image10
		GadgMac	79,80,450,64,Image11
		GadgMac	80,81,481,64,A20
		GadgMac	81,82,506,64,A20
		GadgMac	82,83,531,64,A20

Gadg83		dc.l	Gadg84
		dc.w	89,75,225,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Isp,0,0,0,0
		dc.w	83
		dc.l	0

Gadg84		dc.l	Gadg85
		dc.w	481,75,49,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Im0,0,0,0,0
		dc.w	84
		dc.l	0

		GadgMac	85,86,531,75,A20

Gadg86		dc.l	Gadg89
		dc.w	556,64,24,21
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE,BOOLGADGET
		dc.l	Image13,0,0,0,0
		dc.w	86
		dc.l	0

Gadg89		dc.l	Gadg90
		dc.w	12,53,27,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!TOGGLESELECT
		dc.w	BOOLGADGET
		dc.l	Image06,0,0,0,0
		dc.w	89
		dc.l	0

Gadg90		dc.l	Gadg91
		dc.w	12,64,40,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!TOGGLESELECT
		dc.w	BOOLGADGET
		dc.l	Ish,0,0,0,0
		dc.w	90
		dc.l	0

Gadg91		dc.l	Gadg92
		dc.w	328,64,65,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!TOGGLESELECT
		dc.w	BOOLGADGET
		dc.l	Image09,0,0,0,0
		dc.w	91
		dc.l	0

Gadg92		dc.l	Gadg93
		dc.w	31,75,27,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!TOGGLESELECT
		dc.w	BOOLGADGET
		dc.l	Image12,0,0,0,0
		dc.w	92
		dc.l	0

Gadg93		dc.l	CSIGadg
		dc.w	344,75,27,10
		dc.w	GADGHCOMP!GADGIMAGE,GADGIMMEDIATE!TOGGLESELECT
		dc.w	BOOLGADGET
		dc.l	Image12,0,0,0,0
		dc.w	93
		dc.l	0

CSIGadg		dc.l	0
		dc.w	452,112,48,10
		dc.w	GADGHCOMP!GADGIMAGE!GADGDISABLED,RELVERIFY,BOOLGADGET
		dc.l	CSI,0,0,0,0
		dc.w	94
		dc.l	0

SqrText		dc.b	1,0,1
		dc.w	168,113
		dc.l	NormText,SqrTxt,DeadText
SqrTxt		dc.b	" ",0

DeadText	dc.b	1,0,1
		dc.w	96,113
		dc.l	NormText,DeadTxt,0
DeadTxt		dc.b	"       ",0
		even
DDeadTxt	dc.b	"       ",0
		even

SqrBord1	dc.w	162,111
		dc.b	1,0,0,6
		dc.l	SqrAry1,SqrBord2
SqrAry1		dc.w	0,11,0,0,18,0,18,11,1,11,1,0

SqrBord2	dc.w	162,111
		dc.b	1,0,0,2
		dc.l	SqrAry2,SqrBord3
SqrAry2		dc.w	19,0,19,11

SqrBord3	dc.w	91,111
		dc.b	1,0,0,6
		dc.l	SqrAry3,SqrBord4
SqrAry3		dc.w	0,11,0,0,64,0,64,11,1,11,1,0

SqrBord4	dc.w	91,111
		dc.b	1,0,0,2
		dc.l	SqrAry4,StrBord1
SqrAry4		dc.w	63,1,63,11

MyBord1		dc.w	64,53
		dc.b	2,1,0,2
		dc.l	MyKeyAry1,MyBord2
MyKeyAry1	dc.w	-25,10,-2,10

MyBord2		dc.w	64,53
		dc.b	3,1,0,4
		dc.l	MyKeyAry2,MyBord3
MyKeyAry2	dc.w	-8,1,-5,1,-5,2,-8,2

MyBord3		dc.w	58,85
		dc.b	2,1,0,2
		dc.l	MyKeyAry3,SqrBord1
MyKeyAry3	dc.w	0,0,286,0

MoreText	dc.b	0,1,0
		dc.w	62,76
		dc.l	ItalFont,MoreTxt,0
MoreTxt		dc.b	"A",0

ItalFont	dc.l	NormFont
		dc.w	8
		dc.b	FSF_BOLD!FSF_ITALIC,0
		even

IconWindow	dc.w	0,0,80,23
		dc.b	0,1
		dc.l	GADGETUP
		dc.l	WINDOWDRAG!WINDOWDEPTH
		dc.l	IconGadget,0,0,0,0
		dc.w	0,0,0,0,WBENCHSCREEN

IconGadget	dc.l	0
		dc.w	2,10,76,12
		dc.w	GADGHCOMP,RELVERIFY,BOOLGADGET
		dc.l	0,0,IcnGdgtTxt,0,0
		dc.w	1
		dc.l	0
IcnGdgtTxt	dc.b	1,0,0,0
		dc.w	6,2
		dc.l	NormText,IcnGdgtText,0
IcnGdgtText	dc.b	"EditKeys",0
		even

ProjectMenu	dc.l	0
		dc.w	8,0,84,0,MENUENABLED
		dc.l	ProjectName
		dc.l	New
		dc.w	0,0,0,0
ProjectName	dc.b	"Project",0
		even

New		dc.l	Open
		dc.w	0,0,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,NewName,0
		dc.b	"N",0
		dc.l	0
		dc.w	0
NewName		dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,NewText,0
NewText		dc.b	"New",0
		even

Open		dc.l	Save
		dc.w	0,10,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,OpenName,0
		dc.b	"L",0
		dc.l	0
		dc.w	0
OpenName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,OpenText,0
OpenText	dc.b	"Load",0
		even

Save		dc.l	SaveAs
		dc.w	0,20,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,SaveName,0
		dc.b	"S",0
		dc.l	0
		dc.w	0
SaveName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,SaveText,0
SaveText	dc.b	"Save",0
		even

SaveAs		dc.l	About
		dc.w	0,30,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,SaveAsName,0
		dc.b	"A",0
		dc.l	0
		dc.w	0
SaveAsName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,SaveAsText,0
SaveAsText	dc.b	"Save As",0
		even

About		dc.l	Iconify
		dc.w	0,40,80+COMMWIDTH,10
		dc.w	HIGHNONE!ITEMENABLED!ITEMTEXT
		dc.l	0,AboutName,0
		dc.b	0,0
		dc.l	AboutSub
		dc.w	0
AboutName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,AboutText,0
AboutText	dc.b	"About",0
		even

Iconify		dc.l	Quit
		dc.w	0,50,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,IconifyName,0
		dc.b	"E",0
		dc.l	0
		dc.w	0
IconifyName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,IconifyText,0
IconifyText	dc.b	"Sleep",0
		even

Quit		dc.l	0
		dc.w	0,60,80+COMMWIDTH,10
		dc.w	HIGHCOMP!ITEMENABLED!ITEMTEXT!COMMSEQ
		dc.l	0,QuitName,0
		dc.b	"Q",0
		dc.l	0
		dc.w	0
QuitName	dc.b	2,1,0,0
		dc.w	3,1
		dc.l	NormText,QuitText,0
QuitText	dc.b	"Quit",0
		even

AboutSub	dc.l	AboutSub2
		dc.w	101,-8,305,50
		dc.w	HIGHNONE!ITEMENABLED
		dc.l	0,Logo,0
		dc.b	0,0
		dc.l	0
		dc.w	0

AboutSub2	dc.l	0
		dc.w	101,42,305,36
		dc.w	HIGHNONE!ITEMENABLED!ITEMTEXT
		dc.l	0,AbtSubNme1,0
		dc.b	0,0
		dc.l	0
		dc.w	0

AbtSubNme1	dc.b	0,1,0,0
		dc.w	29,2
		dc.l	NormText,AbtSubTxt1,AbtSubNme2
AbtSubTxt1	dc.b	"Copyright (c) 1991 David Kinder",0
		even

AbtSubNme2	dc.b	0,1,0,0
		dc.w	5,15
		dc.l	NormText,AbtSubTxt2,AbtSubNme3
AbtSubTxt2	dc.b	34,"And a thousand thousand slimy things",0
		even

AbtSubNme3	dc.b	0,1,0,0
		dc.w	13,24
		dc.l	NormText,AbtSubTxt3,0
AbtSubTxt3	dc.b	"Lived on; and so did I.",34,0
		even

NormText	dc.l	NormFont
		dc.w	8
		dc.b	0,0
NormFont	dc.b	"topaz.font",0
		even

ReqText		dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,ReqTxt,0
ReqTxt		dc.b	"Do you really want to quit?",0
		even

NSavText	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,NSavTxt,0
NSavTxt		dc.b	"Not enough memory for save buffer!",0
		even

MNewText	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,MNewTxt,0
MNewTxt		dc.b	"The current keymap will be lost. Are you sure?",0
		even

LReqText	dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,LReqTxt,0
LReqTxt		dc.b	"Yes",0
		even

RReqText	dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,RReqTxt,0
RReqTxt		dc.b	"No",0
		even

DoubleReq	dc.l	0
		dc.w	133,15,326,71,0,0
		dc.l	DblGadg1,DblBord1,DblText1
		dc.w	NOISYREQ
		dc.b	1,0
		dc.l	0
		ds.b	32
		dc.l	0,0
		ds.b	36

DblBord1	dc.w	0,0
		dc.b	2,0,0,6
		dc.l	DblAry1,DblBord2
DblAry1		dc.w	0,70,0,0,325,0,325,70,1,70,1,0

DblBord2	dc.w	0,0
		dc.b	2,0,0,2
		dc.l	DblAry2,DblBord3
DblAry2		dc.w	324,1,324,69

DblBord3	dc.w	131,31
		dc.b	2,0,0,6
		dc.l	DblAry3,DblBord4
DblAry3		dc.w	0,12,0,0,64,0,64,12,1,12,1,0

DblBord4	dc.w	131,31
		dc.b	2,0,0,2
		dc.l	DblAry4,0
DblAry4		dc.w	63,1,63,12

DblText1	dc.b	0,0,0,0
		dc.w	15,14
		dc.l	NormText,DblTxt1,DblText2
DblTxt1		dc.b	"Enter deadkey to be used on keyboard.",0
		even

DblText2	dc.b	0,0,0,0
		dc.w	47,34
		dc.l	NormText,DblTxt2,DblText3
DblTxt2		dc.b	"Deadkey:",0
		even

DblText3	dc.b	0,0,0,0
		dc.w	107,5
		dc.l	NormText,DblTxt3,0
DblTxt3		dc.b	"Select Deadkey",0
		even

DblGadg1	dc.l	DblGadg2
		dc.w	16,54,138,11
		dc.w	GADGHCOMP,RELVERIFY!ENDGADGET,BOOLGADGET!REQGADGET
		dc.l	DblGBord1,0,DblGText1,0,0
		dc.w	1
		dc.l	0
DblGText1	dc.b	0,0,0,0
		dc.w	5,2
		dc.l	NormText,DblGTxt1,0
DblGTxt1	dc.b	"Use this deadkey",0
		even

DblGadg2	dc.l	DblGadg3
		dc.w	172,54,138,11
		dc.w	GADGHCOMP,RELVERIFY!ENDGADGET,BOOLGADGET!REQGADGET
		dc.l	DblGBord1,0,DblGText2,0,0
		dc.w	2
		dc.l	0
DblGText2	dc.b	0,0,0,0
		dc.w	5,2
		dc.l	NormText,DblGTxt2,0
DblGTxt2	dc.b	"Cancel requester",0
		even

DblGadg3	dc.l	DblGadg4
		dc.w	260,32,50,11
		dc.w	GADGHCOMP,RELVERIFY,BOOLGADGET!REQGADGET
		dc.l	DblGBord3,0,DblGText3,0,0
		dc.w	3
		dc.l	0
DblGText3	dc.b	0,0,0,0
		dc.w	5,2
		dc.l	NormText,DblGTxt3,0
DblGTxt3	dc.b	"Clear",0
		even

DblGadg4	dc.l	0
		dc.w	130,32,1,1
		dc.w	GADGHNONE,RELVERIFY,BOOLGADGET!REQGADGET
		dc.l	0,0,DblGText4,0,0
		dc.w	0
		dc.l	0
DblGText4	dc.b	0,1,1,0
		dc.w	5,2
		dc.l	NormText,DblGTxt4,0
DblGTxt4	dc.b	"       ",0
		even

DblGBord1	dc.w	-2,-1
		dc.b	2,0,0,6
		dc.l	DblGAry1,DblGBord2
DblGAry1	dc.w	0,12,0,0,141,0,141,12,1,12,1,0

DblGBord2	dc.w	-2,-1
		dc.b	2,0,0,2
		dc.l	DblGAry2,0
DblGAry2	dc.w	140,0,140,11

DblGBord3	dc.w	-2,-1
		dc.b	2,0,0,6
		dc.l	DblGAry3,DblGBord4
DblGAry3	dc.w	0,12,0,0,53,0,53,12,1,12,1,0

DblGBord4	dc.w	-2,-1
		dc.b	2,0,0,2
		dc.l	DblGAry4,0
DblGAry4	dc.w	52,0,52,11

LoseReq		dc.l	0
		dc.w	103,15,365,71,0,0
		dc.l	LsGadg1,LsBord1,LoseText1
		dc.w	0
		dc.b	1,0
		dc.l	0
		ds.b	32
		dc.l	0,0
		ds.b	36

LsGadg1		dc.l	LsGadg2
		dc.w	72,32,56,11
		dc.w	GADGHCOMP!GADGIMAGE,TOGGLESELECT!RELVERIFY
		dc.w	BOOLGADGET!REQGADGET
		dc.l	Ls2,0,0,0,0
		dc.w	1
		dc.l	0

LsGadg2		dc.l	LsGadg3
		dc.w	72+58,32,56,11
		dc.w	GADGHCOMP!SELECTED,TOGGLESELECT!RELVERIFY
		dc.w	BOOLGADGET!REQGADGET
		dc.l	0,0,0,0,0
		dc.w	2
		dc.l	0

LsGadg3		dc.l	LsGadg4
		dc.w	72+116,32,56,11
		dc.w	GADGHCOMP,TOGGLESELECT!RELVERIFY
		dc.w	BOOLGADGET!REQGADGET
		dc.l	0,0,0,0,0
		dc.w	3
		dc.l	0

LsGadg4		dc.l	LsGadg5
		dc.w	11,54,74,11
		dc.w	GADGHCOMP!GADGIMAGE,RELVERIFY!ENDGADGET
		dc.w	BOOLGADGET!REQGADGET
		dc.l	Ls1,0,0,0,0
		dc.w	4
		dc.l	0

LsGadg5		dc.l	0
		dc.w	166,54,186,11
		dc.w	GADGHCOMP,RELVERIFY!ENDGADGET,BOOLGADGET!REQGADGET
		dc.l	LsGBord1,0,LsGText5,0,0
		dc.w	5
		dc.l	0
LsGText5	dc.b	0,0,0,0
		dc.w	5,2
		dc.l	NormText,LsGTxt5,0
LsGTxt5		dc.b	"Forget the whole thing",0
		even

LsGBord1	dc.w	-2,-1
		dc.b	2,0,0,6
		dc.l	LsGAry1,LsGBord2
LsGAry1		dc.w	0,12,0,0,189,0,189,12,1,12,1,0

LsGBord2	dc.w	-2,-1
		dc.b	2,0,0,2
		dc.l	LsGAry2,0
LsGAry2		dc.w	188,0,188,11

LsBord1		dc.w	0,0
		dc.b	2,0,0,6
		dc.l	LsAry1,LsBord2
LsAry1		dc.w	0,70,0,0,364,0,364,70,1,70,1,0

LsBord2		dc.w	0,0
		dc.b	2,0,0,2
		dc.l	LsAry2,0
LsAry2		dc.w	363,1,363,69

LoseText1	dc.b	0,0,0,0
		dc.w	47,5
		dc.l	NormText,LoseTxt1,LoseText2
LoseTxt1	dc.b	"Some key definitions must be lost.",0
		even

LoseText2	dc.b	0,0,0,0
		dc.w	7,14
		dc.l	NormText,LoseTxt2,LoseText3
LoseTxt2	dc.b	"Select type to loose then click on Complete.",0
		even

LoseText3	dc.b	0,0,0,0
		dc.w	23,34
		dc.l	NormText,LoseTxt3,0
LoseTxt3	dc.b	"Loose                        definitions",0
		even

HlpText1	dc.b	0,0,0,0
		dc.w	9,7
		dc.l	NormText,HlpTxt1,HlpText2
HlpTxt1		dc.b	"EditKeys allows you to edit keymap files, which"
		dc.b	" control what",0
		even

HlpText2	dc.b	0,0,0,0
		dc.w	9,16
		dc.l	NormText,HlpTxt2,HlpText3
HlpTxt2		dc.b	"programs 'see' when a key is depressed.  To learn"
		dc.b	" more about",0
		even

HlpText3	dc.b	0,0,0,0
		dc.w	9,25
		dc.l	NormText,HlpTxt3,0
HlpTxt3		dc.b	"keymaps and this program, read the text file"
		dc.b	" 'EditKeys.Doc'.",0
		even

IntName		INTNAME
GrafName	GRAFNAME
DosName		DOSNAME
AslLibName	AslName
WBName		dc.b	"workbench.library",0
		even
ArpName		dc.b	"arp.library",0
		even

ArpFileReq	dc.l	fr_LHail,fr_File,fr_Dir,0
		dc.b	0,0
		dc.l	0,0
fr_LHail	dc.b	"Load Keymap",0
		even
fr_SHail	dc.b	"Save Keymap",0
		even
fr_Dir		dc.b	"DEVS:keymaps"
		ds.b	64-12
PathName	dc.b	"DEVS:keymaps/"
		ds.b	128-13
		even

xDir		dc.l	fr_Dir
xFile		dc.l	fr_File

LoadTags	dc.l	ASL_Hail,fr_LHail,ASL_Dir,fr_Dir,TAG_DONE
SaveTags	dc.l	ASL_Hail,fr_SHail,ASL_FuncFlags,FILF_SAVE
		dc.l	ASL_Dir,fr_Dir,TAG_DONE

FileErr1	dc.b	27,"[0m",27,"[1m",27,"[33mEditKeys v1.2",10,10
		dc.b	27,"[0mCould not load ",34
FileErr1End	even

FileErr2	dc.b	34,10
FileErr2End	even

IntgErr1	dc.b	27,"[0m",27,"[1m",27,"[33mEditKeys v1.2",10,10
		dc.b	27,"[0m",34
IntgErr1End	even

IntgErr2	dc.b	34," is not a valid keymap!",10
IntgErr2End	even

NoArpErr	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,NoArpTxt,NArp1
NoArpTxt	dc.b	"Error: Could not open arp.library.",0
		even
NArp1		dc.b	2,1,0,0
		dc.w	9,27
		dc.l	NormText,NArp1T,NArp2
NArp1T		dc.b	"Run 'CopyArp' or copy arp.library",0
		even
NArp2		dc.b	2,1,0,0
		dc.w	9,36
		dc.l	NormText,NArp2T,NArp3
NArp2T		dc.b	"to the 'libs' directory of your",0
		even
NArp3		dc.b	2,1,0,0
		dc.w	9,45
		dc.l	NormText,NArp3T,KeyHeadText
NArp3T		dc.b	"boot disk.",0
		even

WBNoFile	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,NoFileTxt,KeyHeadText
NoFileTxt	dc.b	"Error: Could not load specified keymap.",0
		even

WBFaultFile	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,FaultFileTxt,KeyHeadText
FaultFileTxt	dc.b	"Error: Specified file is not a keymap.",0
		even

KeyHeadText	dc.b	3,1,0,0
		dc.w	9,5
		dc.l	BoldText,KeyHeadTxt,0
KeyHeadTxt	dc.b	"EditKeys v1.2",0
		even

BoldText	dc.l	NormFont
		dc.w	8
		dc.b	FSF_BOLD,0

AbortText	dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,AbortTxt,0
AbortTxt	dc.b	"Abort",0
		even

Par_Help	dc.b	27,"[0m",27,"[1m",27,"[33mEditKeys v1.2",10
		dc.b	27,"[0m© 1991 by David Kinder",10,10
		dc.b	"Format: EditKeys [<keymap>] [NOMAP]",10
Par_Modify	dc.b	0
Par_Temp	dc.b	"KEYMAP,NOMAP/S",0
		even

OpenErr1	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,NoFileTxt,0

OpenErr2	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,FaultFileTxt,0

OpenSErr	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,OpSTxt,0
OpSTxt		dc.b	"Cannot open keymap for saving.",0
		even

ContText	dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,ContTxt,0
ContTxt		dc.b	"Continue",0
		even

DeadQuest	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,DQTxt1,DeadQuest2
DQTxt1		dc.b	"This physical key already has a deadkey definition.",0
		even

DeadQuest2	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,DQTxt2,0
DQTxt2		dc.b	"Do you wish the new deadkey to be the same?",0
		even

VanText		dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,VanTxt,VanText2
VanTxt		dc.b	"This key is undefined for the CTRL qualifier.",0
		even

VanText2	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,VanTxt2,0
VanTxt2		dc.b	"What effect should CTRL have on this key?",0
		even

VanPos		dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,VanPTxt,0
VanPTxt		dc.b	"Clear bits 5&6",0
		even

VanNeg		dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,VanNTxt,0
VanNTxt		dc.b	"None",0
		even

EdText		dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,EdTxt,EdText2
EdTxt		dc.b	"This key cannot be uniquely defined"
		even

EdText2		dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,EdTxt2,0
EdTxt2		dc.b	"without losing other definitions.",0
		even

EdPos		dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,EdPTxt,0
EdPTxt		dc.b	"Modify key",0
		even

NoEdText	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,NoEdTxt,0
NoEdTxt		dc.b	"This key cannot be uniquely defined.",0
		even

ZapText1	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,ZapTxt1,ZapText2
ZapTxt1		dc.b	"I could convert this key from STRING to NORMAL,",0
		even

ZapText2	dc.b	0,1,0,0
		dc.w	9,16
		dc.l	NormText,ZapTxt2,ZapText3
ZapTxt2		dc.b	"but I'll have to zap the CONTROL definitions...",0
		even

ZapText3	dc.b	0,1,0,0
		dc.w	9,25
		dc.l	NormText,ZapTxt3,0
ZapTxt3		dc.b	"What should I do?",0
		even

ZapNo		dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,ZapNoTxt,0
ZapNoTxt	dc.b	"Forget it",0
		even

NoDeadSText	dc.b	0,1,0,0
		dc.w	9,7
		dc.l	NormText,NoDeadSTxt,0
NoDeadSTxt	dc.b	"This physical key cannot accept strings.",0
		even

SoM		dc.b	"The Sisters of Mercy",0
		even
SoM1		dc.b	2,1,0,0
		dc.w	9,7
		dc.l	NormText,SoM1T,SoM2
SoM1T		dc.b	34,"I hear the roar of a big machine",0
		even
SoM2		dc.b	2,1,0,0
		dc.w	17,16
		dc.l	NormText,SoM2T,SoM3
SoM2T		dc.b	"Two worlds and in between",0
		even
SoM3		dc.b	2,1,0,0
		dc.w	17,25
		dc.l	NormText,SoM3T,SoM4
SoM3T		dc.b	"Love lost, fire at will",0
		even
SoM4		dc.b	2,1,0,0
		dc.w	17,34
		dc.l	NormText,SoM4T,SoM5
SoM4T		dc.b	"Dum-dum bullets and shoot to kill, I hear",0
		even
SoM5		dc.b	2,1,0,0
		dc.w	17,43
		dc.l	NormText,SoM5T,SoM6
SoM5T		dc.b	"Dive, bombers, and",0
		even
SoM6		dc.b	2,1,0,0
		dc.w	17,52
		dc.l	NormText,SoM6T,SoM7
SoM6T		dc.b	"Empire down",0
		even
SoM7		dc.b	2,1,0,0
		dc.w	17,61
		dc.l	NormText,SoM7T,0
SoM7T		dc.b	"Empire down",34,0
		even
LucText		dc.b	0,1,0,0
		dc.w	6,3
		dc.l	NormText,LucTxt,0
LucTxt		dc.b	"Lucretia",0
		even

WBTxt		dc.b	"EditKeys",0
		even

KeysToMap	dc.l	Gadg12,Gadg13,Gadg14,Gadg15,Gadg16,Gadg17,Gadg18,Gadg19
		dc.l	Gadg20,Gadg21,Gadg22,Gadg23,Gadg24,Gadg25,0,Gadg84
		dc.l	Gadg34,Gadg35,Gadg36,Gadg37,Gadg38,Gadg39,Gadg40,Gadg41
		dc.l	Gadg42,Gadg43,Gadg44,Gadg45,0,Gadg80,Gadg81,Gadg82
		dc.l	Gadg51,Gadg52,Gadg53,Gadg54,Gadg55,Gadg56,Gadg57,Gadg58
		dc.l	Gadg59,Gadg60,Gadg61,Gadg87,0,Gadg63,Gadg64,Gadg65
		dc.l	Gadg88,Gadg67,Gadg68,Gadg69,Gadg70,Gadg71,Gadg72,Gadg73
		dc.l	Gadg74,Gadg75,Gadg76,0,Gadg85,Gadg47,Gadg48,Gadg49
		dc.l	Gadg83,Gadg26,Gadg33,Gadg86,Gadg46,Gadg01,Gadg27,0
		dc.l	0,0,Gadg50,0,Gadg62,Gadg78,Gadg79,Gadg77
		dc.l	Gadg02,Gadg03,Gadg04,Gadg05,Gadg06,Gadg07,Gadg08,Gadg09
		dc.l	Gadg10,Gadg11,Gadg29,Gadg30,Gadg31,Gadg32,Gadg66,Gadg28

MapToKeys	dc.b	$45,$50,$51,$52,$53,$54,$55,$56
		dc.b	$57,$58,$59,$00,$01,$02,$03,$04
		dc.b	$05,$06,$07,$08,$09,$0a,$0b,$0c
		dc.b	$0d,$41,$46,$5f,$5a,$5b,$5c,$5d
		dc.b	$42,$10,$11,$12,$13,$14,$15,$16
		dc.b	$17,$18,$19,$1a,$1b,$44,$3d,$3e
		dc.b	$3f,$4a,$20,$21,$22,$23,$24,$25
		dc.b	$26,$27,$28,$29,$2a,$4c,$2d,$2e
		dc.b	$2f,$5e,$31,$32,$33,$34,$35,$36
		dc.b	$37,$38,$39,$3a,$4f,$4d,$4e,$1d
		dc.b	$1e,$1f,$40,$0f,$3c,$43,$2b,$30

IDtoGadget	dc.l	0,0,0,0,0,0,0,0
		dc.l	0,0,0,0,Gadg13,Gadg14,Gadg15,Gadg16
		dc.l	Gadg17,Gadg18,Gadg19,Gadg20,Gadg21,Gadg22,Gadg23,Gadg24
		dc.l	Gadg25,0,0,0,Gadg29,Gadg30,Gadg31,Gadg32
		dc.l	0,Gadg34,Gadg35,Gadg36,Gadg37,Gadg38,Gadg39,Gadg40
		dc.l	Gadg41,Gadg42,Gadg43,Gadg44,Gadg45,0,Gadg47,Gadg48
		dc.l	Gadg49,Gadg50,Gadg51,Gadg52,Gadg53,Gadg54,Gadg55,Gadg56
		dc.l	Gadg57,Gadg58,Gadg59,Gadg60,Gadg61,0,Gadg63,Gadg64
		dc.l	Gadg65,Gadg66,Gadg67,Gadg68,Gadg69,Gadg70,Gadg71,Gadg72
		dc.l	Gadg73,Gadg74,Gadg75,Gadg76,0,0,0,Gadg80
		dc.l	Gadg81,Gadg82,0,0,Gadg85,0,Gadg87,Gadg88

DeadIDtoGadg	dc.l	Gadg01,Gadg02,Gadg03,Gadg04,Gadg05,Gadg06,Gadg07,Gadg08
		dc.l	Gadg09,Gadg10,Gadg11,Gadg12,Gadg13,Gadg14,Gadg15,Gadg16
		dc.l	Gadg17,Gadg18,Gadg19,Gadg20,Gadg21,Gadg22,Gadg23,Gadg24
		dc.l	Gadg25,Gadg26,Gadg27,Gadg28,Gadg29,Gadg30,Gadg31,Gadg32
		dc.l	Gadg33,Gadg34,Gadg35,Gadg36,Gadg37,Gadg38,Gadg39,Gadg40
		dc.l	Gadg41,Gadg42,Gadg43,Gadg44,Gadg45,Gadg46,Gadg47,Gadg48
		dc.l	Gadg49,Gadg50,Gadg51,Gadg52,Gadg53,Gadg54,Gadg55,Gadg56
		dc.l	Gadg57,Gadg58,Gadg59,Gadg60,Gadg61,Gadg62,Gadg63,Gadg64
		dc.l	Gadg65,Gadg66,Gadg67,Gadg68,Gadg69,Gadg70,Gadg71,Gadg72
		dc.l	Gadg73,Gadg74,Gadg75,Gadg76,Gadg77,Gadg78,Gadg79,Gadg80
		dc.l	Gadg81,Gadg82,Gadg83,Gadg84,Gadg85,Gadg86,Gadg87,Gadg88

Tab___		dc.b	0,0,0,0,0,0,0,0
TabS__		dc.b	0,1,0,1,0,1,0,1
Tab_A_		dc.b	0,0,1,2,0,0,1,2
Tab__C		dc.b	0,0,0,0,1,2,2,-1
TabSA_		dc.b	0,1,1,3,0,1,1,3
Tab_AC		dc.b	0,0,1,2,1,2,3,-1
TabS_C		dc.b	0,1,0,1,1,3,2,-1
TabSAC		dc.b	0,1,1,3,1,3,3,-1

QualTable	dc.l	Tab___,Tab__C,TabS__,TabS_C
		dc.l	Tab_A_,Tab_AC,TabSA_,TabSAC

DTab___		dc.b	0,0,0,0,0,0,0,0
DTab_A_		dc.b	0,0,2,4,0,0,2,4
DTab__C		dc.b	0,0,0,0,2,4,4,8
DTabS__		dc.b	0,2,0,2,0,2,0,2
DTab_AC		dc.b	0,0,2,4,2,4,6,12
DTabSA_		dc.b	0,2,2,6,0,2,2,6
DTabS_C		dc.b	0,2,0,2,2,6,4,10
DTabSAC		dc.b	0,2,2,6,2,6,6,14

DQualTab	dc.l	DTab___,DTab__C,DTabS__,DTabS_C
		dc.l	DTab_A_,DTab_AC,DTabSA_,DTabSAC

CheckTab	dc.b	0,8,2,10,4,12,6,14

On_Value	dc.w	GADGHCOMP!GADGIMAGE!SELECTED

KeyTab1		dc.b	$40,$41,$42,$43,$44,$45,$46,$4c,$4d,$4e,$4f,$50,$51
		dc.b	$52,$53,$54,$55,$56,$57,$58,$59,$5f
KeyTab1End	even
KeyTab2		dc.b	"Spc","Bck","Tab","Ent","Ret","Esc","Del","Up ","Dwn"
		dc.b	"Rgt","Lft","F1 ","F2 ","F3 ","F4 ","F5 ","F6 ","F7 "
		dc.b	"F8 ","F9 ","F10","Hlp"
		even

MyMode		dc.b	1,0
LastGadgVal	dc.l	-1
KeyTypes	dcb.b	96,KCF_NOP

		section	BSS,BSS

DeadIndex	ds.b	4096
StringArea	ds.b	8192

fr_File		ds.b	64
StringBuf	ds.b	34
SavePath	ds.b	128
ArgBuf		ds.b	128

CapsTab		ds.b	96
ReptTab		ds.b	96
UseDead		ds.b	16
ModIndex	ds.b	256
StringList	ds.b	832
DeadTab		ds.w	768
KeyDefs		ds.l	96

_IntuitionBase	ds.l	1
_GfxBase	ds.l	1
_DOSBase	ds.l	1
_AslBase	ds.l	1
_WorkbenchBase	ds.l	1

ReturnMsg	ds.l	1
Windowhd	ds.l	1
UserPort	ds.l	1
RPort		ds.l	1
MySegment	ds.l	1
NoDeadStore	ds.l	1
DeadStore	ds.l	1
MyDefKey	ds.l	1
SaveBuffer	ds.l	1
SaveBuffer2	ds.l	1
SaveDeadBuf1	ds.l	1
SaveDeadBuf2	ds.l	1
LastQualVal	ds.l	1
AslFReq		ds.l	1
MyWBPort	ds.l	1
Par_Arry	ds.l	2
Parms		ds.l	2
MD_DeadTab	ds.w	1
MD_DTbPos	ds.w	1
OldDeadOff	ds.w	1
MyNewKey	ds.w	1
StringNow	ds.w	1
ErrResponse	ds.b	1
ModifyIndex	ds.b	1
DeadByte	ds.b	1
MyDefQual	ds.b	1
MD_Index	ds.b	1
MD_KeyType	ds.b	1
MD_GadgNo	ds.b	1
DeadNo		ds.b	1
ModNo		ds.b	1
ChQVal		ds.b	1
CurrDKey	ds.b	1
DCurrDKey	ds.b	1
SisTst		ds.b	1
OS2		ds.b	1
Quest		ds.b	1