From 333b605b2afd472b823aeda0adf0e8b1ea9843c0 Mon Sep 17 00:00:00 2001
From: fishsoupisgood <github@madingley.org>
Date: Mon, 27 May 2019 02:41:51 +0100
Subject: initial commit from asl-1.41r8.tar.gz

---
 code56k.c | 2566 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2566 insertions(+)
 create mode 100644 code56k.c

(limited to 'code56k.c')

diff --git a/code56k.c b/code56k.c
new file mode 100644
index 0000000..07b7415
--- /dev/null
+++ b/code56k.c
@@ -0,0 +1,2566 @@
+/* code56k.c */
+/*****************************************************************************/
+/* AS-Portierung                                                             */
+/*                                                                           */
+/* AS-Codegeneratormodul fuer die DSP56K-Familie                             */
+/*                                                                           */
+/* Historie: 10. 6.1996 Grundsteinlegung                                     */
+/*            7. 6.1998 563xx-Erweiterungen fertiggestellt                   */
+/*            7. 7.1998 Fix Zugriffe auf CharTransTable wg. signed chars     */
+/*           18. 8.1998 BookKeeping-Aufruf bei RES                           */
+/*            2. 1.1999 ChkPC-Anpassung                                      */
+/*                                                                           */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <string.h>
+#include <ctype.h>
+
+#include "strutil.h"
+#include "chunks.h"
+#include "asmdef.h"
+#include "asmsub.h"
+#include "asmpars.h"
+#include "codepseudo.h"
+#include "codevars.h"
+
+#include "code56k.h"
+
+typedef struct 
+         {
+          char *Name;
+          LongWord Code;
+          CPUVar MinCPU;
+         } FixedOrder;
+
+typedef enum {ParAB,ParABShl1,ParABShl2,ParXYAB,ParABXYnAB,ParABBA,ParXYnAB,ParMul,ParFixAB} ParTyp;
+typedef struct 
+         {
+          char *Name;
+          ParTyp Typ;
+          Byte Code;
+         } ParOrder;
+
+#define FixedOrderCnt 14
+
+#define ParOrderCnt 31
+
+#define BitOrderCnt 4
+static char *BitOrders[BitOrderCnt]={"BCLR","BSET","BCHG","BTST"};
+
+#define BitJmpOrderCnt 4
+static char *BitJmpOrders[BitJmpOrderCnt]={"JCLR","JSET","JSCLR","JSSET"};
+
+#define BitBrOrderCnt 4
+static char *BitBrOrders[BitBrOrderCnt]={"BRCLR","BRSET","BSCLR","BSSET"};
+
+#define ImmMacOrderCnt 4
+static char *ImmMacOrders[ImmMacOrderCnt]={"MPYI","MPYRI","MACI","MACRI"};
+
+static Byte MacTable[4][4]={{0,2,5,4},{2,0xff,6,7},{5,6,1,3},{4,7,3,0xff}};
+
+static Byte Mac4Table[4][4]={{0,13,10,4},{5,1,14,11},{2,6,8,15},{12,3,7,9}};
+
+static Byte Mac2Table[4]={1,3,2,0};
+
+#define ModNone (-1)
+#define ModImm 0
+#define MModImm (1 << ModImm)
+#define ModAbs 1
+#define MModAbs (1 << ModAbs)
+#define ModIReg 2
+#define MModIReg (1 << ModIReg)
+#define ModPreDec 3
+#define MModPreDec (1 << ModPreDec)
+#define ModPostDec 4
+#define MModPostDec (1 << ModPostDec)
+#define ModPostInc 5
+#define MModPostInc (1 << ModPostInc)
+#define ModIndex 6
+#define MModIndex (1 << ModIndex)
+#define ModModDec 7
+#define MModModDec (1 << ModModDec)
+#define ModModInc 8
+#define MModModInc (1 << ModModInc)
+#define ModDisp 9
+#define MModDisp (1 << ModDisp)
+
+#define MModNoExt (MModIReg+MModPreDec+MModPostDec+MModPostInc+MModIndex+MModModDec+MModModInc)
+#define MModNoImm (MModAbs+MModNoExt)
+#define MModAll (MModNoImm+MModImm)
+
+#define SegLData (SegYData+1)
+
+#define MSegCode (1 << SegCode)
+#define MSegXData (1 << SegXData)
+#define MSegYData (1 << SegYData)
+#define MSegLData (1 << SegLData)
+
+static CPUVar CPU56000,CPU56002,CPU56300;
+static IntType AdrInt;
+static LargeWord MemLimit;
+static ShortInt AdrType;
+static LongInt AdrMode;
+static LongInt AdrVal;
+static Byte AdrSeg;
+
+static FixedOrder *FixedOrders;
+static ParOrder *ParOrders;
+
+/*----------------------------------------------------------------------------------------------*/
+
+	static void AddFixed(char *Name, LongWord Code, CPUVar NMin) 
+BEGIN
+   if (InstrZ>=FixedOrderCnt) exit(255);
+   
+   FixedOrders[InstrZ].Name=Name;
+   FixedOrders[InstrZ].Code=Code;
+   FixedOrders[InstrZ++].MinCPU=NMin;
+END
+
+	static void AddPar(char *Name, ParTyp Typ, LongWord Code) 
+BEGIN
+   if (InstrZ>=ParOrderCnt) exit(255);
+   
+   ParOrders[InstrZ].Name=Name;
+   ParOrders[InstrZ].Typ=Typ;
+   ParOrders[InstrZ++].Code=Code;
+END
+
+	static void InitFields(void)
+BEGIN
+   FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0;
+   AddFixed("NOP"    , 0x000000, CPU56000);
+   AddFixed("ENDDO"  , 0x00008c, CPU56000);
+   AddFixed("ILLEGAL", 0x000005, CPU56000);
+   AddFixed("RESET"  , 0x000084, CPU56000);
+   AddFixed("RTI"    , 0x000004, CPU56000);
+   AddFixed("RTS"    , 0x00000c, CPU56000);
+   AddFixed("STOP"   , 0x000087, CPU56000);
+   AddFixed("SWI"    , 0x000006, CPU56000);
+   AddFixed("WAIT"   , 0x000086, CPU56000);
+   AddFixed("DEBUG"  , 0x000200, CPU56300);
+   AddFixed("PFLUSH" , 0x000003, CPU56300);
+   AddFixed("PFLUSHUN",0x000001, CPU56300);
+   AddFixed("PFREE"  , 0x000002, CPU56300);
+   AddFixed("TRAP"   , 0x000006, CPU56300);
+
+   ParOrders=(ParOrder *) malloc(sizeof(ParOrder)*ParOrderCnt); InstrZ=0;
+   AddPar("ABS" ,ParAB,     0x26);
+   AddPar("ASL" ,ParABShl1, 0x32);
+   AddPar("ASR" ,ParABShl1, 0x22);
+   AddPar("CLR" ,ParAB,     0x13);
+   AddPar("LSL" ,ParABShl2, 0x33);
+   AddPar("LSR" ,ParABShl2, 0x23);
+   AddPar("NEG" ,ParAB,     0x36);
+   AddPar("NOT" ,ParAB,     0x17);
+   AddPar("RND" ,ParAB,     0x11);
+   AddPar("ROL" ,ParAB,     0x37);
+   AddPar("ROR" ,ParAB,     0x27);
+   AddPar("TST" ,ParAB,     0x03);
+   AddPar("ADC" ,ParXYAB,   0x21);
+   AddPar("SBC" ,ParXYAB,   0x25);
+   AddPar("ADD" ,ParABXYnAB,0x00);
+   AddPar("CMP" ,ParABXYnAB,0x05);
+   AddPar("CMPM",ParABXYnAB,0x07);
+   AddPar("SUB" ,ParABXYnAB,0x04);
+   AddPar("ADDL",ParABBA,   0x12);
+   AddPar("ADDR",ParABBA,   0x02);
+   AddPar("SUBL",ParABBA,   0x16);
+   AddPar("SUBR",ParABBA,   0x06);
+   AddPar("AND" ,ParXYnAB,  0x46);
+   AddPar("EOR" ,ParXYnAB,  0x43);
+   AddPar("OR"  ,ParXYnAB,  0x42);
+   AddPar("MAC" ,ParMul,    0x82);
+   AddPar("MACR",ParMul,    0x83);
+   AddPar("MPY" ,ParMul,    0x80);
+   AddPar("MPYR",ParMul,    0x81);
+   AddPar("MAX" ,ParFixAB,  0x1d);
+   AddPar("MAXM",ParFixAB,  0x15);
+END
+
+	static void DeinitFields(void)
+BEGIN
+  free(FixedOrders);
+  free(ParOrders);
+END
+
+/*----------------------------------------------------------------------------------------------*/
+
+	static void SplitArg(char *Orig, char *LDest, char *RDest)
+BEGIN
+   char *p,*str;
+
+   str=strdup(Orig);
+   p=QuotPos(str,',');
+   if (p==Nil)
+    BEGIN
+     *RDest='\0'; strcpy(LDest,str);
+    END
+   else
+    BEGIN
+     *p='\0';
+      strcpy(LDest,str); strcpy(RDest,p+1);
+    END
+   free(str);
+END
+
+	static void ChkMask(Word Erl, Byte ErlSeg)
+BEGIN
+   if ((AdrType!=ModNone) AND ((Erl & (1 << AdrType))==0))
+    BEGIN
+     WrError(1350); AdrCnt=0; AdrType=ModNone;
+    END
+   if ((AdrSeg!=SegNone) AND ((ErlSeg & (1 << AdrSeg))==0))
+    BEGIN
+     WrError(1960); AdrCnt=0; AdrType=ModNone;
+    END
+END
+
+        static void CutSize(char *Asc, Byte *ShortMode)
+BEGIN
+   switch (*Asc)
+    BEGIN
+     case '>':
+      strcpy(Asc,Asc+1); *ShortMode=2;
+      break;
+     case '<':
+      strcpy(Asc,Asc+1); *ShortMode=1;
+      break;
+     default:
+      *ShortMode=0;
+    END  
+END
+
+	static Boolean DecodeReg(char *Asc, LongInt *Erg)
+BEGIN
+#define RegCount 12
+   static char *RegNames[RegCount]=
+	    {"X0","X1","Y0","Y1","A0","B0","A2","B2","A1","B1","A","B"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      *Erg=z+4; return True;
+     END
+   if ((strlen(Asc)==2) AND (Asc[1]>='0') AND (Asc[1]<='7'))
+    switch (toupper(*Asc))
+     BEGIN
+      case 'R':
+       *Erg=16+Asc[1]-'0'; return True;
+      case 'N':
+       *Erg=24+Asc[1]-'0'; return True;
+     END
+   return False;
+END
+
+	static Boolean DecodeALUReg(char *Asc, LongInt *Erg, 
+                                    Boolean MayX, Boolean MayY, Boolean MayAcc)
+BEGIN
+   Boolean Result=False;
+
+   if (NOT DecodeReg(Asc,Erg)) return Result;
+   switch (*Erg)
+    BEGIN
+     case 4:
+     case 5:
+      if (MayX)
+	BEGIN
+	 Result=True; (*Erg)-=4;
+	END
+      break;
+     case 6:
+     case 7:
+      if (MayY)
+       BEGIN
+	Result=True; (*Erg)-=6;
+       END
+      break;
+     case 14:
+     case 15:
+      if (MayAcc)
+       BEGIN
+	Result=True;
+	if ((MayX) OR (MayY)) (*Erg)-=12; else (*Erg)-=14;
+       END
+      break;
+    END
+
+   return Result;
+END
+
+	static Boolean DecodeLReg(char *Asc, LongInt *Erg)
+BEGIN
+#undef RegCount
+#define RegCount 8
+   static char *RegNames[RegCount]=
+	    {"A10","B10","X","Y","A","B","AB","BA"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      *Erg=z; return True;
+     END
+
+   return False;
+END
+
+	static Boolean DecodeXYABReg(char *Asc, LongInt *Erg)
+BEGIN
+#undef RegCount
+#define RegCount 8
+   static char *RegNames[RegCount]=
+	    {"B","A","X","Y","X0","Y0","X1","Y1"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      *Erg=z; return True;
+     END
+
+   return False;
+END
+
+	static Boolean DecodeXYAB0Reg(char *Asc, LongInt *Erg)
+BEGIN
+#undef RegCount
+#define RegCount 6
+   static char *RegNames[RegCount]=
+	    {"A0","B0","X0","Y0","X1","Y1"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      *Erg=z+2; return True;
+     END
+
+   return False;
+END
+
+	static Boolean DecodeXYAB1Reg(char *Asc, LongInt *Erg)
+BEGIN
+#undef RegCount
+#define RegCount 6
+   static char *RegNames[RegCount]=
+	    {"A1","B1","X0","Y0","X1","Y1"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      *Erg=z+2; return True;
+     END
+
+   return False;
+END
+
+	static Boolean DecodePCReg(char *Asc, LongInt *Erg)
+BEGIN
+#undef RegCount
+#define RegCount 8              /** vvvv ab 56300 ? */
+   static char *RegNames[RegCount]={"SZ","SR","OMR","SP","SSH","SSL","LA","LC"};
+   Word z;
+
+   for (z=0; z<RegCount; z++)
+    if (strcasecmp(Asc,RegNames[z])==0)
+     BEGIN
+      (*Erg)=z; return True;
+     END
+
+   return False;
+END
+
+	static Boolean DecodeAddReg(char *Asc, LongInt *Erg)
+BEGIN
+   if ((strlen(Asc)==2) AND (toupper(*Asc)=='M') AND (Asc[1]>='0') AND (Asc[1]<='7'))
+    BEGIN
+     *Erg=Asc[1]-'0'; return True;
+    END
+   /* >=56300 ? */
+   if (strcasecmp(Asc,"EP")==0)
+    BEGIN
+     *Erg=0x0a; return True;
+    END
+   if (strcasecmp(Asc,"VBA")==0)
+    BEGIN
+     *Erg=0x10; return True;
+    END
+   if (strcasecmp(Asc,"SC")==0)
+    BEGIN
+     *Erg=0x11; return True;
+    END
+    
+   return False;
+END	
+
+	static Boolean DecodeGeneralReg(char *Asc, LongInt *Erg)
+BEGIN
+   if (DecodeReg(Asc,Erg)) return True;
+   if (DecodePCReg(Asc,Erg))
+    BEGIN
+     (*Erg)+=0x38; return True;
+    END
+   if (DecodeAddReg(Asc,Erg))
+    BEGIN
+     (*Erg)+=0x20; return True;
+    END
+   return False;
+END
+
+        static Boolean DecodeCtrlReg(char *Asc, LongInt *Erg)
+BEGIN
+   if (DecodeAddReg(Asc,Erg)) return True;
+   if (DecodePCReg(Asc,Erg))
+    BEGIN
+     (*Erg)+=0x18; return True;
+    END
+   return False;
+END
+
+	static Boolean DecodeControlReg(char *Asc, LongInt *Erg)
+BEGIN
+   Boolean Result=True;
+
+   if (strcasecmp(Asc,"MR")==0) *Erg=0;
+   else if (strcasecmp(Asc,"CCR")==0) *Erg=1;
+   else if ((strcasecmp(Asc,"OMR")==0) OR (strcasecmp(Asc,"COM")==0)) *Erg=2;
+   else if ((strcasecmp(Asc,"EOM")==0) AND (MomCPU>=CPU56000)) *Erg=3;
+   else Result=False;
+
+   return Result;
+END
+
+	static void DecodeAdr(char *Asc_O, Word Erl, Byte ErlSeg)
+BEGIN
+   static char *ModMasks[ModModInc+1]=
+	    {"","","(Rx)","-(Rx)","(Rx)-","(Rx)+","(Rx+Nx)","(Rx)-Nx","(Rx)+Nx"};
+   static Byte ModCodes[ModModInc+1]=
+	    {0,0,4,7,2,3,5,0,1};
+#define SegCount 4
+   static char SegNames[SegCount]={'P','X','Y','L'};
+   static Byte SegVals[SegCount]={SegCode,SegXData,SegYData,SegLData};
+   int z,l;
+   Boolean OK;
+   Byte OrdVal;
+   String Asc;
+   char *pp,*np,save;
+
+   AdrType=ModNone; AdrCnt=0; strmaxcpy(Asc,Asc_O,255);
+
+   /* Adressierungsmodi vom 56300 abschneiden */
+   
+   if ((MomCPU<CPU56300) AND ((Erl & MModDisp)!=0)) Erl-=MModDisp;
+      
+   /* Defaultsegment herausfinden */
+
+   if ((ErlSeg & MSegXData)!=0) AdrSeg=SegXData;
+   else if ((ErlSeg & MSegYData)!=0) AdrSeg=SegYData;
+   else if ((ErlSeg & MSegCode)!=0) AdrSeg=SegCode;
+   else AdrSeg=SegNone;
+
+   /* Zielsegment vorgegeben ? */
+
+   for (z=0; z<SegCount; z++)
+    if ((toupper(*Asc)==SegNames[z]) AND (Asc[1]==':'))
+     BEGIN
+      AdrSeg=SegVals[z]; strcpy(Asc,Asc+2);
+     END
+
+   /* Adressausdruecke abklopfen: dazu mit Referenzstring vergleichen */
+
+   for (z=ModIReg; z<=ModModInc; z++)
+    if (strlen(Asc)==strlen(ModMasks[z]))
+     BEGIN
+      AdrMode=0xffff;
+      for (l=0; l<=strlen(Asc); l++)
+       if (ModMasks[z][l]=='x')
+	BEGIN
+	 OrdVal=Asc[l]-'0';
+	 if (OrdVal>7) break;
+	 else if (AdrMode==0xffff) AdrMode=OrdVal;
+	 else if (AdrMode!=OrdVal)
+	  BEGIN
+	   WrError(1760); ChkMask(Erl,ErlSeg); return;
+	  END
+	END
+       else if (ModMasks[z][l]!=toupper(Asc[l])) break;
+       if (l>strlen(Asc))
+        BEGIN
+	 AdrType=z; AdrMode+=ModCodes[z] << 3;
+	 ChkMask(Erl,ErlSeg); return;
+        END
+     END
+
+   /* immediate ? */
+
+   if (*Asc=='#')
+    BEGIN
+     AdrVal=EvalIntExpression(Asc+1,Int24,&OK);
+     if (OK)
+      BEGIN
+       AdrType=ModImm; AdrCnt=1; AdrMode=0x34; 
+       ChkMask(Erl,ErlSeg); return;
+      END
+    END
+
+   /* Register mit Displacement bei 56300 */
+
+   if (IsIndirect(Asc))
+    BEGIN
+     strcpy(Asc,Asc+1); Asc[strlen(Asc)-1]='\0';
+     pp=strchr(Asc,'+'); np=strchr(Asc,'-');
+     if ((pp==Nil) OR ((np!=Nil) AND (np<pp))) pp=np;
+     if (pp!=0)
+      BEGIN
+       save=*pp; *pp='\0';
+       if ((DecodeGeneralReg(Asc,&AdrMode)) AND (AdrMode>=16) AND (AdrMode<=23))
+        BEGIN
+         *pp=save;
+         AdrMode-=16; FirstPassUnknown=False;
+         AdrVal=EvalIntExpression(pp,Int24,&OK);
+         if (OK)
+          BEGIN
+           if (FirstPassUnknown) AdrVal&=63;
+           AdrType=ModDisp;
+          END
+         ChkMask(Erl,ErlSeg); return;
+        END 
+       *pp=save;
+      END
+    END
+
+   /* dann absolut */
+
+   AdrVal=EvalIntExpression(Asc,AdrInt,&OK);
+   if (OK)
+    BEGIN
+     AdrType=ModAbs; AdrMode=0x30; AdrCnt=1;
+     if ((AdrSeg & ((1<<SegCode)|(1<<SegXData)|(1<<SegYData)))!=0) ChkSpace(AdrSeg);
+     ChkMask(Erl,ErlSeg); return;
+    END
+END
+
+	static Boolean DecodeOpPair(char *Left, char *Right, Byte WorkSeg,
+			      LongInt *Dir, LongInt *Reg1, LongInt *Reg2,
+			      LongInt *AType, LongInt *AMode, LongInt *ACnt,
+                              LongInt *AVal)
+BEGIN
+   Boolean Result=False;
+
+   if (DecodeALUReg(Left,Reg1,WorkSeg==SegXData,WorkSeg==SegYData,True))
+    BEGIN
+     if (DecodeALUReg(Right,Reg2,WorkSeg==SegXData,WorkSeg==SegYData,True))
+      BEGIN
+       *Dir=2; Result=True;
+      END
+     else
+      BEGIN
+       *Dir=0; *Reg2=(-1);
+       DecodeAdr(Right,MModNoImm,1 << WorkSeg);
+       if (AdrType!=ModNone)
+	BEGIN
+	 *AType=AdrType; *AMode=AdrMode; *ACnt=AdrCnt; *AVal=AdrVal;
+	 Result=True;
+	END
+      END
+    END
+   else if (DecodeALUReg(Right,Reg1,WorkSeg==SegXData,WorkSeg==SegYData,True))
+    BEGIN
+     *Dir=1; *Reg2=(-1);
+     DecodeAdr(Left,MModAll,1 << WorkSeg);
+     if (AdrType!=ModNone)
+      BEGIN
+       *AType=AdrType; *AMode=AdrMode; *ACnt=AdrCnt; *AVal=AdrVal;
+       Result=True;
+      END
+    END
+
+   return Result;
+END
+
+	static LongInt TurnXY(LongInt Inp)
+BEGIN
+   switch (Inp)
+    BEGIN
+     case 4:
+     case 7:
+      return Inp-4;
+     case 5:
+     case 6:
+      return 7-Inp;
+     default:  /* wird nie erreicht */
+      return 0;
+    END
+END
+
+	static Boolean DecodeTFR(char *Asc, LongInt *Erg)
+BEGIN
+   LongInt Part1,Part2;
+   String Left,Right;
+
+   SplitArg(Asc,Left,Right);
+   if (NOT DecodeALUReg(Right,&Part2,False,False,True)) return False;
+   if (NOT DecodeReg(Left,&Part1)) return False;
+   if ((Part1<4) OR ((Part1>7) AND (Part1<14)) OR (Part1>15)) return False;
+   if (Part1>13)
+    if (((Part1 ^ Part2) & 1)==0) return False;
+    else Part1=0;
+   else Part1=TurnXY(Part1)+4;
+   *Erg=(Part1 << 1)+Part2;
+   return True;
+END
+
+        static Boolean DecodeRR(char *Asc, LongInt *Erg)
+BEGIN
+   LongInt Part1,Part2;
+   String Left,Right;
+
+   SplitArg(Asc,Left,Right);
+   if (NOT DecodeGeneralReg(Right,&Part2)) return False;
+   if ((Part2<16) OR (Part2>23)) return False;
+   if (NOT DecodeGeneralReg(Left,&Part1)) return False;
+   if ((Part1<16) OR (Part1>23)) return False;
+   *Erg=(Part2 & 7)+((Part1 & 7) << 8);
+   return True;
+END
+
+	static Boolean DecodeCondition(char *Asc, Word *Erg)
+BEGIN
+#define CondCount 18
+   static char  *CondNames[CondCount]=
+  	        {"CC","GE","NE","PL","NN","EC","LC","GT","CS","LT","EQ","MI",
+	         "NR","ES","LS","LE","HS","LO"};
+   Boolean Result;
+
+   (*Erg)=0;
+   while ((*Erg<CondCount) AND (strcasecmp(CondNames[*Erg],Asc)!=0)) (*Erg)++;
+   if (*Erg==CondCount-1) *Erg=8;
+   Result=(*Erg<CondCount);
+   *Erg&=15;
+   return Result;
+END
+
+	static Boolean DecodeMOVE_0(void)
+BEGIN
+   DAsmCode[0]=0x200000; CodeLen=1;
+   return True;
+END
+
+	static Boolean DecodeMOVE_1(int Start)
+BEGIN
+   String Left,Right;
+   LongInt RegErg,RegErg2,IsY,MixErg,l;
+   char c;
+   Word Condition;
+   Boolean Result=False;
+   Byte SegMask;
+
+   if (strncasecmp(ArgStr[Start],"IF",2)==0)
+    BEGIN
+     l=strlen(ArgStr[Start]);
+     if (strcasecmp(ArgStr[Start]+l-2,".U")==0)
+      BEGIN
+       RegErg=0x1000; l-=2;
+      END
+     else RegErg=0;
+     c=ArgStr[Start][l]; ArgStr[Start][l]='\0';
+     if (DecodeCondition(ArgStr[Start]+2,&Condition))
+      if (MomCPU<CPU56300) WrError(1505);
+      else
+       BEGIN
+        DAsmCode[0]=0x202000+(Condition << 8)+RegErg;
+        CodeLen=1;
+        return True;
+       END
+     ArgStr[Start][l]=c;
+    END
+
+   SplitArg(ArgStr[Start],Left,Right);
+
+   /* 1. Register-Update */
+
+   if (*Right=='\0')
+    BEGIN
+     DecodeAdr(Left,MModPostDec+MModPostInc+MModModDec+MModModInc,0);
+     if (AdrType!=ModNone)
+      BEGIN
+       Result=True;
+       DAsmCode[0]=0x204000+(AdrMode << 8);
+       CodeLen=1;
+      END
+     return Result;
+    END
+
+   /* 2. Ziel ist Register */
+
+   if (DecodeReg(Right,&RegErg))
+    BEGIN
+     AdrSeg=SegNone;
+     if (DecodeReg(Left,&RegErg2))
+      BEGIN
+       Result=True;
+       DAsmCode[0] = 0x200000 + (RegErg << 8) + (RegErg2 << 13);
+       CodeLen=1;
+      END
+     else
+      BEGIN
+       /* A und B gehen auch als L:..., in L-Zweig zwingen! */
+       SegMask=MSegXData+MSegYData;
+       if ((RegErg==14) OR (RegErg==15)) SegMask|=MSegLData;
+       DecodeAdr(Left,MModAll+MModDisp,SegMask);
+       if (AdrSeg!=SegLData)
+        BEGIN
+         IsY=Ord(AdrSeg==SegYData);
+         MixErg = ((RegErg & 0x18) << 17) + (IsY << 19) + ((RegErg & 7) << 16);
+         if (AdrType==ModDisp)
+          if ((AdrVal<63) AND (AdrVal>-64) AND (RegErg<=15))
+           BEGIN
+            DAsmCode[0]=0x020090+((AdrVal & 1) << 6)+((AdrVal & 0x7e) << 10)
+                        +(AdrMode << 8)+(IsY << 5)+RegErg;
+            CodeLen=1;
+           END
+          else
+           BEGIN
+            DAsmCode[0]=0x0a70c0+(AdrMode << 8)+(IsY << 16)+RegErg;
+            DAsmCode[1]=AdrVal;
+            CodeLen=2;
+           END
+#ifdef __STDC__
+         else if ((AdrType==ModImm) AND ((AdrVal & 0xffffff00u)==0))
+#else
+         else if ((AdrType==ModImm) AND ((AdrVal & 0xffffff00)==0))
+#endif
+  	  BEGIN
+           Result=True;
+           DAsmCode[0] = 0x200000 + (RegErg << 16) + ((AdrVal & 0xff) << 8);
+	   CodeLen=1;
+	  END
+         else if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+	  BEGIN
+	   Result=True;
+	   DAsmCode[0] = 0x408000 + MixErg + (AdrVal << 8);
+	   CodeLen=1;
+	  END
+         else if (AdrType!=ModNone)
+	  BEGIN
+	   Result=True;
+	   DAsmCode[0] = 0x40c000 + MixErg + (AdrMode << 8);
+           DAsmCode[1] = AdrVal;
+	   CodeLen=1+AdrCnt;
+	  END
+	END
+      END
+     if (AdrSeg!=SegLData) return Result;
+    END
+
+   /* 3. Quelle ist Register */
+
+   if (DecodeReg(Left,&RegErg))
+    BEGIN
+     /* A und B gehen auch als L:..., in L-Zweig zwingen! */
+     SegMask=MSegXData+MSegYData;
+     if ((RegErg==14) OR (RegErg==15)) SegMask|=MSegLData;
+     DecodeAdr(Right,MModNoImm+MModDisp,SegMask);
+     if (AdrSeg!=SegLData)
+      BEGIN
+       IsY=Ord(AdrSeg==SegYData);
+       MixErg=((RegErg & 0x18) << 17) + (IsY << 19) + ((RegErg & 7) << 16);
+       if (AdrType==ModDisp)
+        if ((AdrVal<63) AND (AdrVal>-64) AND (RegErg<=15))
+         BEGIN
+          DAsmCode[0]=0x020080+((AdrVal & 1) << 6)+((AdrVal & 0x7e) << 10)
+                      +(AdrMode << 8)+(IsY << 5)+RegErg;
+          CodeLen=1;
+         END
+        else
+         BEGIN
+          DAsmCode[0]=0x0a7080+(AdrMode << 8)+(IsY << 16)+RegErg;
+          DAsmCode[1]=AdrVal;
+          CodeLen=2;
+         END
+       else if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+        BEGIN
+         Result=True;
+         DAsmCode[0] = 0x400000 + MixErg + (AdrVal << 8);
+         CodeLen=1;
+        END
+       else if (AdrType!=ModNone)
+        BEGIN
+         Result=True;
+         DAsmCode[0] = 0x404000 + MixErg + (AdrMode << 8); 
+         DAsmCode[1] = AdrVal;
+         CodeLen=1+AdrCnt;
+        END
+       return Result;
+      END 
+    END
+
+   /* 4. Ziel ist langes Register */
+
+   if (DecodeLReg(Right,&RegErg))
+    BEGIN
+     DecodeAdr(Left,MModNoImm,MSegLData);
+     MixErg=((RegErg & 4) << 17) + ((RegErg & 3) << 16);
+     if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+      BEGIN
+       Result=True;
+       DAsmCode[0] = 0x408000 + MixErg + (AdrVal << 8);
+       CodeLen=1;
+      END
+     else
+      BEGIN
+       Result=True;
+       DAsmCode[0] = 0x40c000 + MixErg + (AdrMode << 8); 
+       DAsmCode[1] = AdrVal;
+       CodeLen=1+AdrCnt;
+      END
+     return Result;
+    END
+
+   /* 5. Quelle ist langes Register */
+
+   if (DecodeLReg(Left,&RegErg))
+    BEGIN
+     DecodeAdr(Right,MModNoImm,MSegLData);
+     MixErg=((RegErg & 4) << 17)+((RegErg & 3) << 16);
+     if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+      BEGIN
+       Result=True;
+       DAsmCode[0] = 0x400000 + MixErg + (AdrVal << 8);
+       CodeLen=1;
+      END
+     else
+      BEGIN
+       Result=True;
+       DAsmCode[0] = 0x404000 + MixErg + (AdrMode << 8); 
+       DAsmCode[1] = AdrVal;
+       CodeLen=1+AdrCnt;
+      END
+     return Result;
+    END
+
+   WrError(1350); return Result;
+END
+
+	static Boolean DecodeMOVE_2(int Start)
+BEGIN
+   String Left1,Right1,Left2,Right2;
+   LongInt RegErg,Reg1L,Reg1R,Reg2L,Reg2R;
+   LongInt Mode1,Mode2,Dir1,Dir2,Type1,Type2,Cnt1,Cnt2,Val1,Val2;
+   Boolean Result=False;
+
+   SplitArg(ArgStr[Start],Left1,Right1);
+   SplitArg(ArgStr[Start+1],Left2,Right2);
+
+   /* 1. Spezialfall X auf rechter Seite ? */
+
+   if (strcasecmp(Left2,"X0")==0)
+    BEGIN
+     if (NOT DecodeALUReg(Right2,&RegErg,False,False,True)) WrError(1350);
+     else if (strcmp(Left1,Right2)!=0) WrError(1350);
+     else
+      BEGIN
+       DecodeAdr(Right1,MModNoImm,MSegXData);
+       if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1+AdrCnt;
+	 DAsmCode[0] = 0x080000 + (RegErg << 16) + (AdrMode << 8);
+	 DAsmCode[1] = AdrVal;
+	 Result=True;
+	END
+      END
+     return Result;
+    END
+
+   /* 2. Spezialfall Y auf linker Seite ? */
+
+   if (strcasecmp(Left1,"Y0")==0)
+    BEGIN
+     if (NOT DecodeALUReg(Right1,&RegErg,False,False,True)) WrError(1350);
+     else if (strcmp(Left2,Right1)!=0) WrError(1350);
+     else
+      BEGIN
+       DecodeAdr(Right2,MModNoImm,MSegYData);
+       if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1+AdrCnt;
+	 DAsmCode[0] = 0x088000 + (RegErg << 16) + (AdrMode << 8);
+	 DAsmCode[1] = AdrVal;
+	 Result=True;
+	END
+      END
+     return Result;
+    END
+
+   /* der Rest..... */
+
+   if ((DecodeOpPair(Left1,Right1,SegXData,&Dir1,&Reg1L,&Reg1R,&Type1,&Mode1,&Cnt1,&Val1))
+   AND (DecodeOpPair(Left2,Right2,SegYData,&Dir2,&Reg2L,&Reg2R,&Type2,&Mode2,&Cnt2,&Val2)))
+    BEGIN
+     if ((Reg1R==-1) AND (Reg2R==-1))
+      BEGIN
+       if ((Mode1 >> 3<1) OR (Mode1 >> 3>4) OR (Mode2 >> 3<1) OR (Mode2 >> 3>4)) WrError(1350);
+       else if (((Mode1 ^ Mode2) & 4)==0) WrError(1760);
+       else
+	BEGIN
+	 DAsmCode[0] = 0x800000 + (Dir2 << 22) + (Dir1 << 15) +
+		       (Reg1L << 18) + (Reg2L << 16) + ((Mode1 & 0x1f) << 8)+
+		       ((Mode2 & 3) << 13) + ((Mode2 & 24) << 17);
+	 CodeLen=1; Result=True;
+	END
+      END
+     else if (Reg1R==-1)
+      BEGIN
+       if ((Reg2L<2) OR (Reg2R>1)) WrError(1350);
+       else
+	BEGIN
+	 DAsmCode[0] = 0x100000 + (Reg1L << 18) + ((Reg2L-2) << 17) + (Reg2R << 16) +
+		       (Dir1 << 15) + (Mode1 << 8);
+	 DAsmCode[1] = Val1; 
+         CodeLen=1+Cnt1; Result=True;
+	END
+      END
+     else if (Reg2R==-1)
+      BEGIN
+       if ((Reg1L<2) OR (Reg1R>1)) WrError(1350);
+       else
+	BEGIN
+	 DAsmCode[0] = 0x104000 + (Reg2L << 16) + ((Reg1L-2) << 19) + (Reg1R << 18) +
+		       (Dir2 << 15) + (Mode2 << 8);
+	 DAsmCode[1] = Val2; 
+         CodeLen=1+Cnt2; Result=True;
+	END
+      END
+     else WrError(1350);
+     return Result;
+    END
+
+   WrError(1350); return Result;
+END
+
+	static Boolean DecodeMOVE(int Start)
+BEGIN
+   switch (ArgCnt-Start+1)
+    BEGIN
+     case 0: return DecodeMOVE_0();
+     case 1: return DecodeMOVE_1(Start);
+     case 2: return DecodeMOVE_2(Start);
+     default:
+      WrError(1110); 
+      return False;
+    END
+END
+
+        static Boolean DecodeMix(char *Asc, Word *Erg)
+BEGIN
+   if (strcmp(Asc,"SS")==0) *Erg=0;
+   else if (strcmp(Asc,"SU")==0) *Erg=0x100;
+   else if (strcmp(Asc,"UU")==0) *Erg=0x140;
+   else return False;
+   return True;
+END
+
+
+	static Boolean DecodePseudo(void)
+BEGIN
+   Boolean OK;
+   int BCount;
+   Word AdrWord,z,z2;
+/*   Byte Segment;*/
+   TempResult t;
+   LongInt HInt;
+
+
+   if (Memo("XSFR")) 
+    BEGIN
+     CodeEquate(SegXData,0,MemLimit);
+     return True;
+    END
+
+   if (Memo("YSFR"))
+    BEGIN
+     CodeEquate(SegYData,0,MemLimit);
+     return True;
+    END
+
+   if (Memo("DS"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       FirstPassUnknown=False;
+       AdrWord=EvalIntExpression(ArgStr[1],AdrInt,&OK);
+       if (FirstPassUnknown) WrError(1820);
+       if ((OK) AND (NOT FirstPassUnknown))
+	BEGIN
+	 CodeLen=AdrWord; DontPrint=True;
+         BookKeeping();
+	END
+      END
+     return True;
+    END
+
+   if (Memo("DC"))
+    BEGIN
+     if (ArgCnt<1) WrError(1110);
+     else
+      BEGIN
+       OK=True;
+       for (z=1 ; z<=ArgCnt; z++)
+	if (OK)
+	 BEGIN
+	  FirstPassUnknown=False;
+	  EvalExpression(ArgStr[z],&t);
+	  switch (t.Typ)
+           BEGIN
+	    case TempInt:
+	     if (FirstPassUnknown) t.Contents.Int&=0xffffff;
+	     if (NOT RangeCheck(t.Contents.Int,Int24))
+	      BEGIN
+	       WrError(1320); OK=False;
+	      END
+	     else
+	      BEGIN
+	       DAsmCode[CodeLen++]=t.Contents.Int & 0xffffff;
+	      END
+	     break;
+	    case TempString:
+	     BCount=2; DAsmCode[CodeLen]=0;
+	     for (z2=0; z2<strlen(t.Contents.Ascii); z2++)
+	      BEGIN
+               HInt=t.Contents.Ascii[z2];
+               HInt=CharTransTable[((usint) HInt)&0xff];
+               HInt<<=(BCount*8);
+               DAsmCode[CodeLen]|=HInt;
+	       if (--BCount<0)
+	        BEGIN
+		 BCount=2; DAsmCode[++CodeLen]=0;
+	        END
+	      END
+	     if (BCount!=2) CodeLen++;
+	     break;
+	    default:
+	     WrError(1135); OK=False;
+	   END
+	 END
+      END
+     if (NOT OK) CodeLen=0;
+     return True;
+    END
+
+   return False;
+END
+
+static int ErrCode;
+static char *ErrString;
+
+	static void SetError(int Code)
+BEGIN
+   ErrCode=Code; ErrString="";
+END
+
+	static void SetXError(int Code, char *Ext)
+BEGIN
+   ErrCode=Code; ErrString=Ext;
+END
+
+	static void PrError(void)
+BEGIN
+   if (*ErrString!='\0') WrXError(ErrCode,ErrString);
+   else if (ErrCode!=0) WrError(ErrCode);
+END
+
+	static void MakeCode_56K(void)
+BEGIN
+   int z;
+   LongInt AddVal,h=0,h2,Reg1,Reg2,Reg3;
+   LongInt HVal,HCnt,HMode,HSeg,Dist;
+   LargeInt LAddVal;
+   Word Condition;
+   Boolean OK,DontAdd;
+   String Left,Mid,Right;
+   Byte Size;
+
+   CodeLen=0; DontPrint=False;
+
+   /* zu ignorierendes */
+
+   if (Memo("")) return;
+
+   /* Pseudoanweisungen */
+
+   if (DecodePseudo()) return;
+
+   /* ohne Argument */
+
+   for (z=0; z<FixedOrderCnt; z++)
+    if (Memo(FixedOrders[z].Name))
+     BEGIN
+      if (ArgCnt!=0) WrError(1110);
+      else if (MomCPU<FixedOrders[z].MinCPU) WrError(1500);
+      else
+       BEGIN
+	CodeLen=1; DAsmCode[0]=FixedOrders[z].Code;
+       END;
+      return;
+     END
+
+   /* ALU */
+
+   for (z=0; z<ParOrderCnt; z++)
+    if (Memo(ParOrders[z].Name))
+     BEGIN
+      if (DecodeMOVE(2))
+       BEGIN
+        ErrCode=0; ErrString=""; DontAdd=False;
+        switch (ParOrders[z].Typ)
+         BEGIN
+          case ParAB:
+           if (NOT DecodeALUReg(ArgStr[1],&Reg1,False,False,True)) SetXError(1445,ArgStr[1]);
+           else h=Reg1 << 3;
+           break;
+          case ParFixAB:
+           if (strcasecmp(ArgStr[1],"A,B")!=0) SetError(1760);
+           else h=0;
+           break;
+          case ParABShl1:
+           if (strchr(ArgStr[1],',')==Nil)
+            BEGIN
+             if (NOT DecodeALUReg(ArgStr[1],&Reg1,False,False,True)) SetXError(1445,ArgStr[1]);
+             else h=Reg1 << 3;
+            END
+           else if (ArgCnt!=1) SetError(1950);
+           else if (MomCPU<CPU56300) SetError(1500);
+           else
+            BEGIN
+             SplitArg(ArgStr[1],Left,Right);
+             if (strchr(Right,',')==Nil) strcpy(Mid,Right);
+             else SplitArg(Right,Mid,Right);
+             if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) SetXError(1445,Right);
+             else if (NOT DecodeALUReg(Mid,&Reg2,False,False,True)) SetXError(1445,Mid);
+             else if (*Left=='#')
+              BEGIN
+               AddVal=EvalIntExpression(Left+1,UInt6,&OK);
+               if (OK)
+                BEGIN
+                 DAsmCode[0]=0x0c1c00+((ParOrders[z].Code & 0x10) << 4)+(Reg2 << 7)+
+                             (AddVal << 1)+Reg1;
+                 CodeLen=1; DontAdd=True;
+                END
+              END
+             else if (NOT DecodeXYAB1Reg(Left,&Reg3)) SetXError(1445,Left);
+             else
+              BEGIN
+               DAsmCode[0]=0x0c1e60-((ParOrders[z].Code & 0x10) << 2)+(Reg2 << 4)+
+                           (Reg3 << 1)+Reg1;
+               CodeLen=1; DontAdd=True;
+              END
+            END
+           break;
+          case ParABShl2:
+           if (strchr(ArgStr[1],',')==Nil)
+            BEGIN
+             if (NOT DecodeALUReg(ArgStr[1],&Reg1,False,False,True)) SetXError(1445,ArgStr[1]);
+             else h=Reg1 << 3;
+            END
+           else if (ArgCnt!=1) SetError(1950);
+           else if (MomCPU<CPU56300) SetError(1500);
+           else
+            BEGIN
+             SplitArg(ArgStr[1],Left,Right);
+             if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) SetXError(1445,Right);
+             else if (*Left=='#')
+              BEGIN
+               AddVal=EvalIntExpression(Left+1,UInt5,&OK);
+               if (OK)
+                BEGIN
+                 DAsmCode[0]=0x0c1e80+((0x33-ParOrders[z].Code) << 2)+
+                             (AddVal << 1)+Reg1;
+                 CodeLen=1; DontAdd=True;
+                END
+              END
+             else if (NOT DecodeXYAB1Reg(Left,&Reg3)) SetXError(1445,Left);
+             else
+              BEGIN
+               DAsmCode[0]=0x0c1e10+((0x33-ParOrders[z].Code) << 1)+
+                           (Reg3 << 1)+Reg1;
+               CodeLen=1; DontAdd=True;
+              END
+            END
+           break;
+          case ParXYAB:
+           SplitArg(ArgStr[1],Left,Right);
+           if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) SetXError(1445,Right);
+           else if (NOT DecodeLReg(Left,&Reg1)) SetXError(1445,Left);
+           else if ((Reg1<2) OR (Reg1>3)) SetXError(1445,Left);
+           else h=(Reg2 << 3) + ((Reg1-2) << 4);
+           break;
+          case ParABXYnAB:
+           SplitArg(ArgStr[1],Left,Right);
+           if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) SetXError(1445,Right);
+           else if (*Left=='#')
+            BEGIN
+             if (Memo("CMPM")) SetError(1350);
+             else if (MomCPU<CPU56300) SetError(1500);
+             else if (ArgCnt!=1) SetError(1950);
+             else
+              BEGIN
+               AddVal=EvalIntExpression(Left+1,Int24,&OK);
+               if (NOT OK) SetError(-1);
+               else if ((AddVal>=0) AND (AddVal<=63))
+                BEGIN
+                 DAsmCode[0]=0x014000+(AddVal << 8); h=0x80+(Reg2 << 3);
+                END
+               else
+                BEGIN
+                 DAsmCode[0]=0x014000; h=0xc0+(Reg2 << 3);
+                 DAsmCode[1]=AddVal & 0xffffff; CodeLen=2;
+                END
+              END
+            END
+           else
+            if (NOT DecodeXYABReg(Left,&Reg1)) SetXError(1445,Left);
+            else if ((Reg1 ^ Reg2)==1) SetError(1760);
+            else if ((Memo("CMPM")) AND ((Reg1 &6)==2)) SetXError(1445,Left);
+            else
+             BEGIN
+              if (Reg1<2) Reg1=Ord(NOT Memo("CMPM"));
+              h=(Reg2 << 3) + (Reg1 << 4);
+             END
+           break;
+          case ParABBA:
+           if  (strcasecmp(ArgStr[1],"B,A")==0) h=0;
+           else if (strcasecmp(ArgStr[1],"A,B")==0) h=8;
+           else SetXError(1760,ArgStr[1]);
+           break;
+          case ParXYnAB:
+           SplitArg(ArgStr[1],Left,Right);
+           if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) SetXError(1445,Right);
+           else if (*Left=='#')
+            BEGIN
+             if (MomCPU<CPU56300) SetError(1500);
+             else if (ArgCnt!=1) SetError(1950);
+             else
+              BEGIN
+               AddVal=EvalIntExpression(Left+1,Int24,&OK);
+               if (NOT OK) SetError(-1);
+               else if ((AddVal>=0) AND (AddVal<=63))
+                BEGIN
+                 DAsmCode[0]=0x014080+(AddVal << 8)+(Reg2 << 3)+(ParOrders[z].Code&7);
+                 CodeLen=1;
+                 DontAdd=True;
+                END
+               else
+                BEGIN
+                 DAsmCode[0]=0x0140c0+(Reg2 << 3)+(ParOrders[z].Code&7);
+                 DAsmCode[1]=AddVal & 0xffffff; CodeLen=2;
+                 DontAdd=True;
+                END
+              END
+            END
+           else
+            if (NOT DecodeReg(Left,&Reg1)) SetXError(1445,Left);
+            else if ((Reg1<4) OR (Reg1>7)) SetXError(1445,Left);
+            else h=(Reg2 << 3) + (TurnXY(Reg1) << 4);
+           break;
+          case ParMul:
+           SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right); h=0;
+           if (*Left=='-')
+            BEGIN
+             strcpy(Left,Left+1); h+=4;
+            END
+           else if (*Left=='+') strcpy(Left,Left+1);
+           if (NOT DecodeALUReg(Right,&Reg3,False,False,True)) SetXError(1445,Right);
+           else if (NOT DecodeReg(Left,&Reg1)) SetXError(1445,Left);
+           else if ((Reg1<4) OR (Reg1>7)) SetXError(1445,Left);
+           else if (*Mid=='#')
+            BEGIN
+             if (ArgCnt!=1) WrError(1110);
+             else if (MomCPU<CPU56300) WrError(1500);
+             else
+              BEGIN
+               FirstPassUnknown=False;
+               AddVal=EvalIntExpression(Mid+1,UInt24,&OK);
+               if (FirstPassUnknown) AddVal=1;
+               if ((NOT (SingleBit(AddVal,&LAddVal))) OR (LAddVal>22)) WrError(1540);
+               else
+                BEGIN
+                 LAddVal=23-LAddVal;
+                 DAsmCode[0]=0x010040+(LAddVal << 8)+(Mac2Table[Reg1 & 3] << 4)
+                             +(Reg3 << 3);
+                 CodeLen=1;
+                END
+              END
+            END
+
+           else if (NOT DecodeReg(Mid,&Reg2)) SetXError(1445,Mid);
+           else if ((Reg2<4) OR (Reg2>7)) SetXError(1445,Mid);
+           else if (MacTable[Reg1-4][Reg2-4]==0xff) SetError(1760);
+           else h+=(Reg3 << 3) + (MacTable[Reg1-4][Reg2-4] << 4);
+           break;
+         END
+        if (ErrCode==0)
+         BEGIN
+          if (NOT DontAdd) DAsmCode[0]+=ParOrders[z].Code+h;
+         END
+        else
+         BEGIN
+          if (ErrCode>0) PrError(); CodeLen=0;
+         END
+       END
+      return;
+     END
+
+   if (Memo("DIV"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) WrError(1350);
+       else if (NOT DecodeReg(Left,&Reg1)) WrError(1350);
+       else if ((Reg1<4) OR (Reg1>7)) WrError(1350);
+       else
+	BEGIN
+	 CodeLen=1; 
+         DAsmCode[0] = 0x018040 + (Reg2 << 3) + (TurnXY(Reg1) << 4);
+	END
+      END
+     return;
+    END
+    
+   for (z=0; z<ImmMacOrderCnt; z++)
+    if (Memo(ImmMacOrders[z]))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (MomCPU<CPU56300) WrError(1500);
+      else
+       BEGIN
+        SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+        h=0;
+        switch (*Left)
+         BEGIN
+          case '-':
+           h=4;
+          case '+':
+           strcpy(Left,Left+1);
+         END
+        if ((*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+        else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+        else if (NOT DecodeXYABReg(Mid,&Reg2)) WrXError(1445,Mid);
+        else if ((Reg2<4) OR (Reg2>7)) WrXError(1445,Mid);
+        else if (*Left!='#') WrError(1120);
+        else
+         BEGIN
+          DAsmCode[1]=EvalIntExpression(Left+1,Int24,&OK);
+          if (OK)
+           BEGIN
+            DAsmCode[0]=0x0141c0+z+h+(Reg1 << 3)+((Reg2 & 3) << 4);
+            CodeLen=2;
+           END
+         END
+       END
+      return;
+     END
+
+   if ((strncmp(OpPart,"DMAC",4)==0) AND (DecodeMix(OpPart+4,&Condition)))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+       if (*Left=='-')
+        BEGIN
+         strcpy(Left,Left+1); Condition+=16;
+        END
+       else if (*Left=='+') strcpy(Left,Left+1);
+       if ((*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYAB1Reg(Mid,&Reg2)) WrXError(1445,Mid);
+       else if (Reg2<4) WrXError(1445,Mid);
+       else if (NOT DecodeXYAB1Reg(Left,&Reg3)) WrXError(1445,Left);
+       else if (Reg3<4) WrXError(1445,Left);
+       else
+        BEGIN
+         DAsmCode[0]=0x012480+Condition+(Reg1 << 5)+Mac4Table[Reg3-4][Reg2-4];
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if (((strncmp(OpPart,"MAC",3)==0) OR (strncmp(OpPart,"MPY",3)==0))
+   AND (DecodeMix(OpPart+3,&Condition)))
+    BEGIN
+     if (Condition==0) WrXError(1200,OpPart);
+     else if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       if (OpPart[1]=='A') Condition-=0x100;
+       SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+       if (*Left=='-')
+        BEGIN
+         strcpy(Left,Left+1); Condition+=16;
+        END
+       else if (*Left=='+') strcpy(Left,Left+1);
+       if ((*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYAB1Reg(Mid,&Reg2)) WrXError(1445,Mid);
+       else if (Reg2<4) WrXError(1445,Mid);
+       else if (NOT DecodeXYAB1Reg(Left,&Reg3)) WrXError(1445,Left);
+       else if (Reg3<4) WrXError(1445,Left);
+       else
+        BEGIN
+         DAsmCode[0]=0x012680+Condition+(Reg1 << 5)+Mac4Table[Reg3-4][Reg2-4];
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if ((Memo("INC")) OR (Memo("DEC")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56002) WrError(1500);
+     else if (NOT DecodeALUReg(ArgStr[1],&Reg1,False,False,True)) WrXError(1445,ArgStr[1]);
+     else
+      BEGIN
+       DAsmCode[0]=0x000008+(Ord(Memo("DEC")) << 1)+Reg1;
+       CodeLen=1;
+      END
+     return;
+    END
+
+   if ((Memo("ANDI")) OR (Memo("ORI")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeControlReg(Right,&Reg1)) WrError(1350);
+       else if (*Left!='#') WrError(1120);
+       else
+	BEGIN
+	 h=EvalIntExpression(Left+1,Int8,&OK);
+	 if (OK)
+	  BEGIN
+	   CodeLen=1;
+	   DAsmCode[0] = 0x0000b8 + ((h & 0xff) << 8) + (Ord(Memo("ORI")) << 6) + Reg1;
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("NORM"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) WrError(1350);
+       else if (NOT DecodeReg(Left,&Reg1)) WrError(1350);
+       else if ((Reg1<16) OR (Reg1>23)) WrError(1350);
+       else
+	BEGIN
+	 CodeLen=1; 
+         DAsmCode[0] = 0x01d815 + ((Reg1 & 7) << 8) + (Reg2 << 3);
+	END
+      END
+     return;
+    END
+
+   if (Memo("NORMF"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYAB1Reg(Left,&Reg1)) WrXError(1445,Left);
+       else
+	BEGIN
+         CodeLen=1; DAsmCode[0]=0x0c1e20+Reg2+(Reg1 << 1);
+	END
+      END
+     return;
+    END
+
+   for (z=0; z<BitOrderCnt; z++)
+    if (Memo(BitOrders[z]))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else
+       BEGIN
+        Reg2=((z & 1) << 5) + (((LongInt) z >> 1) << 16);
+        SplitArg(ArgStr[1],Left,Right);
+        if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+        else if (*Left!='#') WrError(1120);
+        else
+         BEGIN
+          h=EvalIntExpression(Left+1,Int8,&OK);
+          if (FirstPassUnknown) h&=15;
+          if (OK)
+           if ((h<0) OR (h>23)) WrError(1320);
+           else if (DecodeGeneralReg(Right,&Reg1))
+            BEGIN
+             CodeLen=1;
+             DAsmCode[0] = 0x0ac040 + h +(Reg1 << 8) + Reg2;
+            END
+           else
+            BEGIN
+             DecodeAdr(Right,MModNoImm,MSegXData+MSegYData);
+             Reg3=Ord(AdrSeg==SegYData) << 6;
+             if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0] = 0x0a0000 + h + (AdrVal << 8) + Reg3 + Reg2;
+              END
+             else if ((AdrType==ModAbs) AND (AdrVal>=MemLimit-0x3f) AND (AdrVal<=MemLimit))
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0] = 0x0a8000 + h + ((AdrVal & 0x3f) << 8) + Reg3 + Reg2;
+              END
+             else if ((AdrType==ModAbs) AND (MomCPU>=CPU56300) AND (AdrVal>=MemLimit-0x7f) AND (AdrVal<=MemLimit-0x40))
+              BEGIN
+               Reg2=((z & 1) << 5) + (((LongInt) z >> 1) << 14);
+               CodeLen=1;
+               DAsmCode[0] = 0x010000 + h + ((AdrVal & 0x3f) << 8) + Reg3 + Reg2;
+              END
+             else if (AdrType!=ModNone)
+              BEGIN
+               CodeLen=1+AdrCnt;
+               DAsmCode[0] = 0x0a4000 + h + (AdrMode << 8) + Reg3 + Reg2;
+               DAsmCode[1] = AdrVal;
+              END
+            END
+         END
+       END
+      return;
+     END
+
+   if ((Memo("EXTRACT")) OR (Memo("EXTRACTU")))
+    BEGIN
+     z=Ord(Memo("EXTRACTU")) << 7;
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+       if ((*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeALUReg(Mid,&Reg2,False,False,True)) WrXError(1445,Mid);
+       else if (*Left=='#')
+        BEGIN
+         DAsmCode[1]=EvalIntExpression(Left+1,Int24,&OK);
+         if (OK)
+          BEGIN
+           DAsmCode[0]=0x0c1800+z+Reg1+(Reg2 << 4); CodeLen=2;
+          END
+        END
+       else if (NOT DecodeXYAB1Reg(Left,&Reg3)) WrXError(1445,Left);
+       else
+        BEGIN
+         DAsmCode[0]=0x0c1a00+z+Reg1+(Reg2 << 4)+(Reg3 << 1);
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if (Memo("INSERT"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+       if ((*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYAB0Reg(Mid,&Reg2)) WrXError(1445,Mid);
+       else if (*Left=='#')
+        BEGIN
+         DAsmCode[1]=EvalIntExpression(Left+1,Int24,&OK);
+         if (OK)
+          BEGIN
+           DAsmCode[0]=0x0c1900+Reg1+(Reg2 << 4); CodeLen=2;
+          END
+        END
+       else if (NOT DecodeXYAB1Reg(Left,&Reg3)) WrXError(1445,Left);
+       else
+        BEGIN
+         DAsmCode[0]=0x0c1b00+Reg1+(Reg2 << 4)+(Reg3 << 1);
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if (Memo("MERGE"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYAB1Reg(Left,&Reg2)) WrXError(1445,Left);
+       else
+        BEGIN
+         DAsmCode[0]=0x0c1b80+Reg1+(Reg2 << 1);
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if (Memo("CLB"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (NOT DecodeALUReg(Left,&Reg1,False,False,True)) WrXError(1445,Left);
+       else if (NOT DecodeALUReg(Right,&Reg2,False,False,True)) WrXError(1445,Right);
+       else
+        BEGIN
+         DAsmCode[0]=0x0c1e00+Reg2+(Reg1 << 1);
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   if (Memo("CMPU"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (NOT DecodeALUReg(Right,&Reg1,False,False,True)) WrXError(1445,Right);
+       else if (NOT DecodeXYABReg(Left,&Reg2)) WrXError(1445,Left);
+       else if ((Reg1 ^ Reg2)==1) WrError(1760);
+       else if ((Reg2 & 6)==2) WrXError(1445,Left);
+       else
+        BEGIN
+         if (Reg2<2) Reg2=0;
+         DAsmCode[0]=0x0c1ff0+(Reg2 << 1)+Reg1;
+         CodeLen=1;
+        END
+      END
+     return;
+    END
+
+   /* Datentransfer */
+
+   if (Memo("MOVE"))
+    BEGIN
+     DecodeMOVE(1);
+     return;
+    END
+
+   if (Memo("MOVEC"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (DecodeCtrlReg(Left,&Reg1))
+        if (DecodeGeneralReg(Right,&Reg2))
+         BEGIN
+          DAsmCode[0]=0x0440a0+(Reg2 << 8)+Reg1; CodeLen=1;
+         END
+        else
+         BEGIN
+          DecodeAdr(Right,MModNoImm,MSegXData+MSegYData);
+          Reg3=(Ord(AdrSeg==SegYData)) << 6;
+          if ((AdrType==ModAbs) AND (AdrVal<=63))
+           BEGIN
+            DAsmCode[0]=0x050020+(AdrVal << 8)+Reg3+Reg1; CodeLen=1;
+           END
+          else
+           BEGIN
+            DAsmCode[0]=0x054020+(AdrMode << 8)+Reg3+Reg1;
+            DAsmCode[1]=AdrVal; CodeLen=1+AdrCnt;
+           END
+         END
+       else if (NOT DecodeCtrlReg(Right,&Reg1)) WrXError(1440,Right);
+       else
+        if (DecodeGeneralReg(Left,&Reg2))
+         BEGIN
+          DAsmCode[0]=0x04c0a0+(Reg2 << 8)+Reg1; CodeLen=1;
+         END
+        else
+         BEGIN
+          DecodeAdr(Left,MModAll,MSegXData+MSegYData);
+          Reg3=(Ord(AdrSeg==SegYData)) << 6;
+          if ((AdrType==ModAbs) AND (AdrVal<=63))
+           BEGIN
+            DAsmCode[0]=0x058020+(AdrVal << 8)+Reg3+Reg1; CodeLen=1;
+           END
+          else if ((AdrType==ModImm) AND (AdrVal<=255))
+           BEGIN
+            DAsmCode[0]=0x0500a0+(AdrVal << 8)+Reg1; CodeLen=1;
+           END
+          else
+           BEGIN
+            DAsmCode[0]=0x05c020+(AdrMode << 8)+Reg3+Reg1;
+            DAsmCode[1]=AdrVal; CodeLen=1+AdrCnt;
+           END
+         END
+      END
+     return;
+    END
+
+   if (Memo("MOVEM"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (DecodeGeneralReg(Left,&Reg1))
+	BEGIN
+	 DecodeAdr(Right,MModNoImm,MSegCode);
+	 if ((AdrType==ModAbs) AND (AdrVal>=0) AND (AdrVal<=63))
+	  BEGIN
+	   CodeLen=1;
+	   DAsmCode[0] = 0x070000 + Reg1 + (AdrVal << 8);
+	  END
+	 else if (AdrType!=ModNone)
+	  BEGIN
+	   CodeLen=1+AdrCnt; 
+           DAsmCode[1] = AdrVal;
+	   DAsmCode[0] = 0x074080 + Reg1 + (AdrMode << 8);
+	  END
+	END
+       else if (NOT DecodeGeneralReg(Right,&Reg2)) WrXError(1445,Right);
+       else
+	BEGIN
+	 DecodeAdr(Left,MModNoImm,MSegCode);
+	 if ((AdrType==ModAbs) AND (AdrVal>=0) AND (AdrVal<=63))
+	  BEGIN
+	   CodeLen=1;
+	   DAsmCode[0] = 0x078000 + Reg2 + (AdrVal << 8);
+	  END
+	 else if (AdrType!=ModNone)
+	  BEGIN
+	   CodeLen = 1+AdrCnt; 
+           DAsmCode[1] = AdrVal;
+	   DAsmCode[0] = 0x07c080 + Reg2 + (AdrMode << 8);
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("MOVEP"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (DecodeGeneralReg(Left,&Reg1))
+	BEGIN
+	 DecodeAdr(Right,MModAbs,MSegXData+MSegYData);
+	 if (AdrType!=ModNone)
+	  if ((AdrVal<=MemLimit) AND (AdrVal>=MemLimit-0x3f))
+	   BEGIN
+	    CodeLen=1;
+	    DAsmCode[0] = 0x08c000 + (Ord(AdrSeg==SegYData) << 16) +
+			  (AdrVal & 0x3f) + (Reg1 << 8);
+	   END
+          else if ((MomCPU>=CPU56300) AND (AdrVal<=MemLimit-0x40) AND (AdrVal>=MemLimit-0x7f))
+           BEGIN
+            CodeLen=1;
+            DAsmCode[0]=0x04c000+(Ord(AdrSeg==SegYData) << 5)+
+                        (Ord(AdrSeg==SegXData) << 7)+
+                        (AdrVal & 0x1f)+((AdrVal & 0x20) << 1)+(Reg1 << 8);
+           END
+          else WrError(1315);
+	END
+       else if (DecodeGeneralReg(Right,&Reg2))
+	BEGIN
+	 DecodeAdr(Left,MModAbs,MSegXData+MSegYData);
+	 if (AdrType!=ModNone)
+	  if ((AdrVal<=MemLimit) AND (AdrVal>=MemLimit-0x3f))
+	   BEGIN
+	    CodeLen=1;
+	    DAsmCode[0] = 0x084000 + (Ord(AdrSeg==SegYData) << 16) +
+			  (AdrVal & 0x3f) + (Reg2 << 8);
+	   END
+          else if ((MomCPU>=CPU56300) AND (AdrVal<=MemLimit-0x40) AND (AdrVal>=MemLimit-0x7f))
+           BEGIN
+            CodeLen=1;
+            DAsmCode[0]=0x044000+(Ord(AdrSeg==SegYData) << 5)+
+                        (Ord(AdrSeg==SegXData) << 7)+
+                        (AdrVal & 0x1f)+((AdrVal & 0x20) << 1)+(Reg2 << 8);
+           END
+          else WrError(1315);
+	END
+       else
+	BEGIN
+	 DecodeAdr(Left,MModAll,MSegXData+MSegYData+MSegCode);
+	 if ((AdrType==ModAbs) AND (AdrSeg!=SegCode) AND (AdrVal>=MemLimit-0x3f) AND (AdrVal<=MemLimit))
+	  BEGIN
+	   HVal=AdrVal & 0x3f; HSeg=AdrSeg;
+	   DecodeAdr(Right,MModNoImm,MSegXData+MSegYData+MSegCode);
+	   if (AdrType!=ModNone)
+	    if (AdrSeg==SegCode)
+	     BEGIN
+	      CodeLen=1+AdrCnt; 
+              DAsmCode[1] = AdrVal;
+	      DAsmCode[0] = 0x084040 + HVal + (AdrMode << 8) +
+			    (Ord(HSeg==SegYData) << 16);
+	     END
+	    else
+	     BEGIN
+	      CodeLen=1+AdrCnt; 
+              DAsmCode[1] = AdrVal;
+	      DAsmCode[0] = 0x084080 + HVal + (AdrMode << 8) +
+			    (Ord(HSeg==SegYData) << 16) +
+			    (Ord(AdrSeg==SegYData) << 6);
+	     END
+	  END
+	 else if ((AdrType==ModAbs) AND (MomCPU>=CPU56300) AND (AdrSeg!=SegCode) AND (AdrVal>=MemLimit-0x7f) AND (AdrVal<=MemLimit-0x40))
+	  BEGIN
+	   HVal=AdrVal & 0x3f; HSeg=AdrSeg;
+	   DecodeAdr(Right,MModNoImm,MSegXData+MSegYData+MSegCode);
+	   if (AdrType!=ModNone)
+	    if (AdrSeg==SegCode)
+	     BEGIN
+	      CodeLen=1+AdrCnt; 
+              DAsmCode[1] = AdrVal;
+	      DAsmCode[0] = 0x008000 + HVal + (AdrMode << 8) +
+			    (Ord(HSeg==SegYData) << 6);
+	     END
+	    else
+	     BEGIN
+	      CodeLen=1+AdrCnt; 
+              DAsmCode[1] = AdrVal;
+	      DAsmCode[0] = 0x070000 + HVal + (AdrMode << 8) +
+			    (Ord(HSeg==SegYData) << 7) +
+			    (Ord(HSeg==SegXData) << 14) +
+			    (Ord(AdrSeg==SegYData) << 6);
+	     END
+	  END
+	 else if (AdrType!=ModNone)
+	  BEGIN
+	   HVal=AdrVal; HCnt=AdrCnt; HMode=AdrMode; HSeg=AdrSeg;
+	   DecodeAdr(Right,MModAbs,MSegXData+MSegYData);
+	   if (AdrType!=ModNone)
+	    if ((AdrVal>=MemLimit-0x3f) AND (AdrVal<=MemLimit))
+	     BEGIN
+	      if (HSeg==SegCode)
+	       BEGIN
+  	        CodeLen=1+HCnt; 
+                DAsmCode[1] = HVal;
+	        DAsmCode[0] = 0x08c040 + (AdrVal & 0x3f) + (HMode << 8) +
+	  		      (Ord(AdrSeg==SegYData) << 16);
+ 	       END
+	      else
+	       BEGIN
+	        CodeLen=1+HCnt;
+                DAsmCode[1] = HVal;
+	        DAsmCode[0] = 0x08c080 + (((Word)AdrVal) & 0x3f) + (HMode << 8) +
+		  	      (Ord(AdrSeg==SegYData) << 16) +
+			      (Ord(HSeg==SegYData) << 6);
+	       END
+	     END
+	    else if ((MomCPU>=CPU56300) AND (AdrVal>=MemLimit-0x7f) AND (AdrVal<=MemLimit-0x40))
+	     BEGIN
+	      if (HSeg==SegCode)
+	       BEGIN
+  	        CodeLen=1+HCnt; 
+                DAsmCode[1] = HVal;
+	        DAsmCode[0] = 0x00c000 + (AdrVal & 0x3f) + (HMode << 8) +
+	  		      (Ord(AdrSeg==SegYData) << 6);
+ 	       END
+	      else
+	       BEGIN
+	        CodeLen=1+HCnt;
+                DAsmCode[1] = HVal;
+	        DAsmCode[0] = 0x078000 + (((Word)AdrVal) & 0x3f) + (HMode << 8) +
+		  	      (Ord(AdrSeg==SegYData) << 7) +
+		  	      (Ord(AdrSeg==SegXData) << 14) +
+			      (Ord(HSeg==SegYData) << 6);
+	       END
+	     END
+	    else WrError(1315);
+	  END
+	END
+      END
+     return;
+    END
+
+   if (Memo("TFR"))
+    BEGIN
+     if (ArgCnt<1) WrError(1110);
+     else if (DecodeMOVE(2))
+      if (DecodeTFR(ArgStr[1],&Reg1))
+       BEGIN
+	DAsmCode[0] += 0x01 + (Reg1 << 3);
+       END
+      else
+       BEGIN
+	WrError(1350); CodeLen=0;
+       END
+     return;
+    END
+
+   if ((*OpPart=='T') AND (DecodeCondition(OpPart+1,&Condition)))
+    BEGIN
+     if ((ArgCnt!=1) AND (ArgCnt!=2)) WrError(1110);
+     else if (DecodeTFR(ArgStr[1],&Reg1))
+      BEGIN
+       if (ArgCnt==1)
+        BEGIN
+         CodeLen=1;
+         DAsmCode[0]=0x020000+(Condition << 12)+(Reg1 << 3);
+        END
+       else if (NOT DecodeRR(ArgStr[2],&Reg2)) WrError(1350);
+       else
+        BEGIN
+         CodeLen=1;
+         DAsmCode[0]=0x030000+(Condition << 12)+(Reg1 << 3)+Reg2;
+        END
+      END
+     else if (ArgCnt!=1) WrError(1110);
+     else if (NOT DecodeRR(ArgStr[1],&Reg1)) WrError(1350);
+     else
+      BEGIN
+       DAsmCode[0]=0x020800+(Condition << 12)+Reg1;
+       CodeLen=1;
+      END
+     return;
+    END
+
+   for (z=0; z<BitBrOrderCnt; z++)
+    if (Memo(BitBrOrders[z]))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else if (MomCPU<CPU56300) WrError(1500);
+      else
+       BEGIN
+        h=(z & 1) << 5;
+        h2=(((LongInt) z) & 2) << 15;
+        SplitArg(ArgStr[1],Left,Right); SplitArg(Right,Mid,Right);
+        if ((*Left=='\0') OR (*Right=='\0') OR (*Mid=='\0')) WrError(1110);
+        else if (*Left!='#') WrError(1120);
+        else
+         BEGIN
+          AddVal=EvalIntExpression(Left+1,Int8,&OK);
+          if (FirstPassUnknown) AddVal&=15;
+          if (OK)
+           if ((AddVal<0) OR (AddVal>23)) WrError(1320);
+           else if (DecodeGeneralReg(Mid,&Reg1))
+            BEGIN
+             CodeLen=1;
+             DAsmCode[0]=0x0cc080+AddVal+(Reg1 << 8)+h+h2;
+            END
+           else
+            BEGIN
+             FirstPassUnknown=False;
+             DecodeAdr(Mid,MModNoImm,MSegXData+MSegYData);
+             Reg3=Ord(AdrSeg==SegYData) << 6;
+             if ((AdrType==ModAbs) AND (FirstPassUnknown)) AdrVal&=0x3f;
+             if ((AdrType==ModAbs) AND (AdrVal<=63) AND (AdrVal>=0))
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0]=0x0c8080+AddVal+(AdrVal << 8)+Reg3+h+h2;
+              END
+             else if ((AdrType==ModAbs) AND (AdrVal>=MemLimit-0x3f) AND (AdrVal<=MemLimit))
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0]=0x0cc000+AddVal+((AdrVal & 0x3f) << 8)+Reg3+h+h2;
+              END
+             else if ((AdrType==ModAbs) AND (AdrVal>=MemLimit-0x7f) AND (AdrVal<=MemLimit-0x40))
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0]=0x048000+AddVal+((AdrVal & 0x3f) << 8)+Reg3+h+(h2 >> 9);
+              END
+             else if (AdrType==ModAbs) WrError(1350);
+             else if (AdrType!=ModNone)
+              BEGIN
+               CodeLen=1;
+               DAsmCode[0]=0x0c8000+AddVal+(AdrMode << 8)+Reg3+h+h2;
+              END
+            END
+         END
+        if (CodeLen==1)
+         BEGIN
+          Dist=EvalIntExpression(Right,AdrInt,&OK)-(EProgCounter()+2);
+          if (OK)
+           BEGIN
+            DAsmCode[1]=Dist & 0xffffff; CodeLen=2;
+           END
+          else CodeLen=0;
+         END
+       END
+      return;
+     END
+
+   if ((Memo("BRA")) OR (Memo("BSR")))
+    BEGIN
+     z=Memo("BRA") ?  0x40 : 0;
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else if (DecodeReg(ArgStr[1],&Reg1))
+      BEGIN
+       if ((Reg1<16) OR (Reg1>23)) WrXError(1445,ArgStr[1]);
+       else
+        BEGIN
+         Reg1-=16;
+         DAsmCode[0]=0x0d1880+(Reg1 << 8)+z;
+         CodeLen=1;
+        END
+      END
+     else
+      BEGIN
+       CutSize(ArgStr[1],&Size);
+       Dist=EvalIntExpression(ArgStr[1],AdrInt,&OK)-(EProgCounter()+1);
+       if (Size==0)
+        Size=((Dist>-256) AND (Dist<255)) ? 1 : 2;
+        switch (Size)
+         BEGIN
+          case 1:
+           if ((NOT SymbolQuestionable) AND ((Dist<-256) OR (Dist>255))) WrError(1370);
+           else
+            BEGIN
+             Dist&=0x1ff;
+             DAsmCode[0]=0x050800+(z << 4)+((Dist & 0x1e0) << 1)+(Dist & 0x1f);
+             CodeLen=1;
+            END
+           break;
+          case 2:
+           Dist--;
+           DAsmCode[0]=0x0d1080+z;
+           DAsmCode[1]=Dist & 0xffffff;
+           CodeLen=2;
+           break;
+         END
+      END
+     return;
+    END
+
+   if ((*OpPart=='B') AND (DecodeCondition(OpPart+1,&Condition)))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else if (DecodeReg(ArgStr[1],&Reg1))
+      BEGIN
+       if ((Reg1<16) OR (Reg1>23)) WrXError(1445,ArgStr[1]);
+       else
+        BEGIN
+         Reg1-=16;
+         DAsmCode[0]=0x0d1840+(Reg1 << 8)+Condition;
+         CodeLen=1;
+        END
+      END
+     else
+      BEGIN
+       CutSize(ArgStr[1],&Size);
+       Dist=EvalIntExpression(ArgStr[1],AdrInt,&OK)-(EProgCounter()+1);
+       if (Size==0)
+        Size=((Dist>-256) AND (Dist<255)) ? 1 : 2;
+       switch (Size)
+        BEGIN
+         case 1:
+          if ((NOT SymbolQuestionable) AND ((Dist<-256) OR (Dist>255))) WrError(1370);
+          else
+           BEGIN
+            Dist&=0x1ff;
+            DAsmCode[0]=0x050400+(Condition << 12)+((Dist & 0x1e0) << 1)+(Dist & 0x1f);
+            CodeLen=1;
+           END
+          break;
+         case 2:
+          Dist--;
+          DAsmCode[0]=0x0d1040+Condition;
+          DAsmCode[1]=Dist & 0xffffff;
+          CodeLen=2;
+          break;
+        END
+      END
+     return;
+    END
+
+   if ((strncmp(OpPart,"BS",2)==0) AND (DecodeCondition(OpPart+2,&Condition)))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else if (DecodeReg(ArgStr[1],&Reg1))
+      BEGIN
+       if ((Reg1<16) OR (Reg1>23)) WrXError(1445,ArgStr[1]);
+       else
+        BEGIN
+         Reg1-=16;
+         DAsmCode[0]=0x0d1800+(Reg1 << 8)+Condition;
+         CodeLen=1;
+        END
+      END
+     else
+      BEGIN
+       CutSize(ArgStr[1],&Size);
+       Dist=EvalIntExpression(ArgStr[1],AdrInt,&OK)-(EProgCounter()+1);
+       if (Size==0)
+        Size=((Dist>-256) AND (Dist<255)) ? 1 : 2;
+       switch (Size)
+        BEGIN
+         case 1:
+          if ((NOT SymbolQuestionable) AND ((Dist<-256) OR (Dist>255))) WrError(1370);
+          else
+           BEGIN
+            Dist&=0x1ff;
+            DAsmCode[0]=0x050000+(Condition << 12)+((Dist & 0x1e0) << 1)+(Dist & 0x1f);
+            CodeLen=1;
+           END
+          break;
+         case 2:
+          Dist--;
+          DAsmCode[0]=0x0d1000+Condition;
+          DAsmCode[1]=Dist & 0xffffff;
+          CodeLen=2;
+          break;
+        END
+      END
+     return;
+    END
+
+   if ((Memo("LUA")) OR (Memo("LEA")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else if (NOT DecodeReg(Right,&Reg1)) WrXError(1445,Right);
+       else if (Reg1>31) WrXError(1445,Right);
+       else
+	BEGIN
+         DecodeAdr(Left,MModModInc+MModModDec+MModPostInc+MModPostDec+MModDisp,MSegXData);
+         if (AdrType==ModDisp)
+          BEGIN
+           if (ChkRange(AdrVal,-64,63))
+            BEGIN
+             AdrVal&=0x7f;
+             DAsmCode[0]=0x040000+(Reg1-16)+(AdrMode << 8)+
+                         ((AdrVal & 0x0f) << 4)+
+                         ((AdrVal & 0x70) << 7);
+              CodeLen=1;
+            END
+          END
+         else if (AdrType!=ModNone)
+          BEGIN
+           CodeLen=1;
+           DAsmCode[0]=0x044000+(AdrMode << 8)+Reg1;
+          END
+        END
+      END
+     return;
+    END
+
+   if (Memo("LRA"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       SplitArg(ArgStr[1],Left,Right);
+       if (*Right=='\0') WrError(1110);
+       else if (NOT DecodeGeneralReg(Right,&Reg1)) WrXError(1445,Right);
+       else if (Reg1>0x1f) WrXError(1445,Right);
+       else if (DecodeGeneralReg(Left,&Reg2))
+        BEGIN
+         if ((Reg2<16) OR (Reg2>23)) WrXError(1445,Left);
+         else
+          BEGIN
+           DAsmCode[0]=0x04c000+((Reg2 & 7) << 8)+Reg1;
+           CodeLen=1;
+          END
+        END
+       else
+        BEGIN
+         DAsmCode[1]=EvalIntExpression(Left,AdrInt,&OK)-(EProgCounter()+2);
+         if (OK)
+          BEGIN
+           DAsmCode[0]=0x044040+Reg1;
+           CodeLen=2;
+          END
+        END
+      END
+     return;
+    END
+
+   if (Memo("PLOCK"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       DecodeAdr(ArgStr[1],MModNoImm,MSegCode);
+       if (AdrType!=ModNone)
+        BEGIN
+         DAsmCode[0]=0x0ac081+(AdrMode << 8); DAsmCode[1]=AdrVal;
+         CodeLen=2;
+        END
+      END
+     return;
+    END
+
+   if ((Memo("PLOCKR")) OR (Memo("PUNLOCKR")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       DAsmCode[1]=(EvalIntExpression(ArgStr[1],AdrInt,&OK)-(EProgCounter()+2)) & 0xffffff;
+       if (OK)
+        BEGIN              /* ANSI :-O */
+         DAsmCode[0]=0x00000e + Ord(Memo("PUNLOCKR")); CodeLen=2;
+        END
+      END
+     return;
+    END
+
+   /* Spruenge */
+
+   if ((Memo("JMP")) OR (Memo("JSR")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       AddVal=Ord(Memo("JSR")) << 16;
+       DecodeAdr(ArgStr[1],MModNoImm,MSegCode);
+       if (AdrType==ModAbs)
+	if ((AdrVal & 0xfff000)==0)
+	 BEGIN
+	  CodeLen=1; DAsmCode[0] = 0x0c0000 + AddVal + (AdrVal & 0xfff);
+	 END
+	else
+	 BEGIN
+	  CodeLen=2; DAsmCode[0] = 0x0af080 + AddVal; 
+          DAsmCode[1] = AdrVal;
+	 END
+       else if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1; DAsmCode[0] = 0x0ac080 + AddVal + (AdrMode << 8);
+	END
+      END
+     return;
+    END
+
+   if ((*OpPart=='J') AND (DecodeCondition(OpPart+1,&Condition)))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       DecodeAdr(ArgStr[1],MModNoImm,MSegCode);
+       if (AdrType==ModAbs)
+	if ((AdrVal & 0xfff000)==0)
+	 BEGIN
+	  CodeLen=1; 
+          DAsmCode[0] = 0x0e0000 + (Condition << 12) + (AdrVal & 0xfff);
+	 END
+	else
+	 BEGIN
+	  CodeLen=2; 
+          DAsmCode[0] = 0x0af0a0 + Condition; 
+          DAsmCode[1] = AdrVal;
+	 END
+       else if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1; 
+         DAsmCode[0] = 0x0ac0a0 + Condition + (AdrMode << 8);
+	END
+      END
+     return;
+    END
+
+   if ((strncmp(OpPart,"JS",2)==0) AND (DecodeCondition(OpPart+2,&Condition)))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       DecodeAdr(ArgStr[1],MModNoImm,MSegCode);
+       if (AdrType==ModAbs)
+	if ((AdrVal & 0xfff000)==0)
+	 BEGIN
+	  CodeLen=1; 
+          DAsmCode[0] = 0x0f0000 + (Condition << 12) + (AdrVal & 0xfff);
+	 END
+	else
+	 BEGIN
+	  CodeLen=2; 
+          DAsmCode[0] = 0x0bf0a0 + Condition; 
+          DAsmCode[1] = AdrVal;
+	 END
+       else if (AdrType!=ModNone)
+	BEGIN
+	 CodeLen=1; 
+         DAsmCode[0] = 0x0bc0a0 + Condition + (AdrMode << 8);
+	END
+      END
+     return;
+    END
+
+   for (z=0; z<BitJmpOrderCnt; z++)
+    if (Memo(BitJmpOrders[z]))
+     BEGIN
+      if (ArgCnt!=1) WrError(1110);
+      else
+       BEGIN
+	SplitArg(ArgStr[1],Left,Mid); SplitArg(Mid,Mid,Right);
+	if ((*Left=='\0') OR (*Mid=='\0') OR (*Right=='\0')) WrError(1110);
+	else if (*Left!='#') WrError(1120);
+	else
+	 BEGIN
+	  DAsmCode[1]=EvalIntExpression(Right,AdrInt,&OK);
+	  if (OK)
+	   BEGIN
+	    h=EvalIntExpression(Left+1,Int8,&OK);
+	    if (FirstPassUnknown) h&=15;
+	    if (OK)
+	     if ((h<0) OR (h>23)) WrError(1320);
+	     else
+	      BEGIN
+	       Reg2=((z & 1) << 5) + (((LongInt)(z >> 1)) << 16);
+	       if (DecodeGeneralReg(Mid,&Reg1))
+	        BEGIN
+		 CodeLen=2;
+		 DAsmCode[0] = 0x0ac000 + h + Reg2 + (Reg1 << 8);
+	        END
+	       else
+	        BEGIN
+		 DecodeAdr(Mid,MModNoImm,MSegXData+MSegYData);
+		 Reg3=Ord(AdrSeg==SegYData) << 6;
+		 if (AdrType==ModAbs)
+		  if ((AdrVal>=0) AND (AdrVal<=63))
+		   BEGIN
+		    CodeLen=2;
+		    DAsmCode[0] = 0x0a0080 + h + Reg2 + Reg3 + (AdrVal << 8);
+		   END
+		  else if ((AdrVal>=MemLimit-0x3f) AND (AdrVal<=MemLimit))
+		   BEGIN
+		    CodeLen=2;
+		    DAsmCode[0] = 0x0a8080 + h + Reg2 + Reg3 + ((AdrVal & 0x3f) << 8);
+		   END
+		  else if ((MomCPU>=CPU56300) AND (AdrVal>=MemLimit-0x7f) AND (AdrVal<=MemLimit-0x40))
+		   BEGIN
+		    CodeLen=2;
+  	            Reg2=((z & 1) << 5) + (((LongInt)(z >> 1)) << 14);
+		    DAsmCode[0] = 0x018080 + h + Reg2 + Reg3 + ((AdrVal & 0x3f) << 8);
+		   END
+		  else WrError(1320);
+		 else
+		  BEGIN
+		   CodeLen=2;
+		   DAsmCode[0] = 0x0a4080 + h + Reg2 + Reg3 + (AdrMode << 8);
+		  END
+	        END
+	      END
+	   END
+	 END
+       END
+      return;
+     END
+
+   if ((Memo("DO")) OR (Memo("DOR")))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else
+      BEGIN
+       z=Ord(Memo("DOR"));
+       SplitArg(ArgStr[1],Left,Right);
+       if ((*Left=='\0') OR (*Right=='\0')) WrError(1110);
+       else
+	BEGIN
+	 DAsmCode[1]=EvalIntExpression(Right,AdrInt,&OK)-1;
+	 if (OK)
+	  BEGIN
+	   ChkSpace(SegCode);
+	   if (strcasecmp(Left,"FOREVER")==0)
+	    BEGIN
+	     if (MomCPU<CPU56300) WrError(1500);
+	     else
+	      BEGIN
+	       DAsmCode[0]=0x000203-z;
+	       CodeLen=2;
+	      END
+	    END
+	   else if (DecodeGeneralReg(Left,&Reg1))
+	    BEGIN
+	     if (Reg1==0x3c) WrXError(1445,Left); /* kein SSH!! */
+	     else
+	      BEGIN
+  	       CodeLen=2;
+	       DAsmCode[0]=0x06c000+(Reg1 << 8)+(z << 4);
+	      END
+	    END
+	   else if (*Left=='#')
+	    BEGIN
+	     Reg1=EvalIntExpression(Left+1,UInt12,&OK);
+	     if (OK)
+	      BEGIN
+	       CodeLen=2;
+	       DAsmCode[0]=0x060080+(Reg1 >> 8)+((Reg1 & 0xff) << 8)+(z << 4);
+	      END
+	    END
+	   else
+	    BEGIN
+	     DecodeAdr(Left,MModNoImm,MSegXData+MSegYData);
+	     if (AdrType==ModAbs)
+	      if ((AdrVal<0) OR (AdrVal>63)) WrError(1320);
+	      else
+	       BEGIN
+		CodeLen=2;
+		DAsmCode[0]=0x060000+(AdrVal << 8)+(Ord(AdrSeg==SegYData) << 6)+(z << 4);
+	       END
+	     else
+	      BEGIN
+	       CodeLen=2;
+	       DAsmCode[0]=0x064000+(AdrMode << 8)+(Ord(AdrSeg==SegYData) << 6)+(z << 4);
+	      END
+	    END
+	  END
+	END
+      END
+     return;
+    END
+
+   if ((strncmp(OpPart,"BRK",3)==0) AND (DecodeCondition(OpPart+3,&Condition)))
+    BEGIN
+     if (ArgCnt!=0) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       DAsmCode[0]=0x00000210+Condition;
+       CodeLen=1;
+      END
+     return;
+    END
+
+   if ((strncmp(OpPart,"TRAP",4)==0) AND (DecodeCondition(OpPart+4,&Condition)))
+    BEGIN
+     if (ArgCnt!=0) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       DAsmCode[0]=0x000010+Condition;
+       CodeLen=1;
+      END
+     return;
+    END
+
+   if ((strncmp(OpPart,"DEBUG",5)==0) AND (DecodeCondition(OpPart+5,&Condition)))
+    BEGIN
+     if (ArgCnt!=0) WrError(1110);
+     else if (MomCPU<CPU56300) WrError(1500);
+     else
+      BEGIN
+       DAsmCode[0]=0x00000300+Condition;
+       CodeLen=1;
+      END
+     return;
+    END
+
+   if (Memo("REP"))
+    BEGIN
+     if (ArgCnt!=1) WrError(1110);
+     else if (DecodeGeneralReg(ArgStr[1],&Reg1))
+      BEGIN
+       CodeLen=1;
+       DAsmCode[0] = 0x06c020 + (Reg1 << 8);
+      END
+     else
+      BEGIN
+       DecodeAdr(ArgStr[1],MModAll,MSegXData+MSegYData);
+       if (AdrType==ModImm)
+	if ((AdrVal<0) OR (AdrVal>0xfff)) WrError(1320);
+	else
+	 BEGIN
+	  CodeLen=1;
+	  DAsmCode[0] = 0x0600a0 + (AdrVal >> 8) + ((AdrVal & 0xff) << 8);
+	 END
+       else if (AdrType==ModAbs)
+        if ((AdrVal<0) OR (AdrVal>63)) WrError(1320);
+        else
+  	 BEGIN
+	  CodeLen=1;
+	  DAsmCode[0] = 0x060020 + (AdrVal << 8) + (Ord(AdrSeg==SegYData) << 6);
+	 END
+       else
+	BEGIN
+	 CodeLen=1+AdrCnt; 
+         DAsmCode[1] = AdrVal;
+	 DAsmCode[0] = 0x064020 + (AdrMode << 8) + (Ord(AdrSeg==SegYData) << 6);
+	END
+      END
+     return;
+    END
+
+   WrXError(1200,OpPart);
+END
+
+	static Boolean IsDef_56K(void)
+BEGIN
+   return ((Memo("XSFR")) OR (Memo("YSFR")));
+END
+
+        static void SwitchFrom_56K(void)
+BEGIN
+   DeinitFields();
+END
+
+	static void SwitchTo_56K(void)
+BEGIN
+   TurnWords=True; ConstMode=ConstModeMoto; SetIsOccupied=False;
+
+   PCSymbol="*"; HeaderID=0x09; NOPCode=0x000000;
+   DivideChars=" \009"; HasAttrs=False;
+   
+   if (MomCPU==CPU56300)
+    BEGIN
+     AdrInt=UInt24; MemLimit=0xffffffl;
+    END
+   else
+    BEGIN
+     AdrInt=UInt16; MemLimit=0xffff;
+    END
+
+   ValidSegs=(1<<SegCode)|(1<<SegXData)|(1<<SegYData);
+   Grans[SegCode ]=4; ListGrans[SegCode ]=4; SegInits[SegCode ]=0;
+   SegLimits[SegCode ] = MemLimit;
+   Grans[SegXData]=4; ListGrans[SegXData]=4; SegInits[SegXData]=0;
+   SegLimits[SegXData] = MemLimit;
+   Grans[SegYData]=4; ListGrans[SegYData]=4; SegInits[SegYData]=0;
+   SegLimits[SegYData] = MemLimit;
+
+   MakeCode=MakeCode_56K; IsDef=IsDef_56K;
+   SwitchFrom=SwitchFrom_56K; InitFields();
+END
+
+	void code56k_init(void)
+BEGIN
+   CPU56000=AddCPU("56000",SwitchTo_56K);
+   CPU56002=AddCPU("56002",SwitchTo_56K);
+   CPU56300=AddCPU("56300",SwitchTo_56K);
+END
+
-- 
cgit v1.2.3