diff -upNr asl-1.42b226/as.c asl-1.42b226-im6100/as.c
--- asl-1.42b226/as.c	2022-07-12 19:56:43.000000000 +0900
+++ asl-1.42b226-im6100/as.c	2022-07-14 20:53:51.028958458 +0900
@@ -150,6 +150,7 @@
 #include "codekenbak.h"
 #include "codecp1600.h"
 #include "codenano.h"
+#include "code6100.h"
 /**          Code21xx};**/
 
 static long StartTime, StopTime;
@@ -4385,6 +4386,7 @@ int main(int argc, char **argv)
     codekenbak_init();
     codecp1600_init();
     codenano_init();
+    code6100_init();
     First = FALSE;
   }
 
diff -upNr asl-1.42b226/as.res asl-1.42b226-im6100/as.res
--- asl-1.42b226/as.res	2022-06-11 17:51:00.000000000 +0900
+++ asl-1.42b226-im6100/as.res	2022-07-20 23:13:36.931623089 +0900
@@ -203,6 +203,14 @@ Message ErrMsgIndexedForIndirect
  "verwende indizierte anstelle indirekter Adressierung"
  "using indexed instead of indirect addressing"
 
+Message ErrMsgNotInNormalmode
+ ""
+ "not allowed in normal mode"
+
+Message ErrMsgNotInPanelmode
+ ""
+ "not allowed in panel mode"
+
 ;*****
 
 Message ErrMsgDoubleDef
@@ -985,6 +993,18 @@ Message ErrMsgInvCBAR
  "ung&uuml;ltiger Wert f&uuml;r CBAR"
  "invalid CBAR value"
 
+Message ErrMsgInAccPageErr
+ ""
+ "page not accessible"
+
+Message ErrMsgInAccFieldErr
+ ""
+ "field not accessible"
+
+Message ErrMsgInvCombination
+ ""
+ "invalid instruction combination"
+
 Message ErrMsgInternalError
  "interner Fehler"
  "internal error"
Binary files asl-1.42b226/asl.core and asl-1.42b226-im6100/asl.core differ
diff -upNr asl-1.42b226/asmerr.c asl-1.42b226-im6100/asmerr.c
--- asl-1.42b226/asmerr.c	2022-06-11 17:51:00.000000000 +0900
+++ asl-1.42b226-im6100/asmerr.c	2022-07-20 23:13:36.062534128 +0900
@@ -251,6 +251,10 @@ static const char *ErrorNum2String(tErro
       msgno = Num_ErrMsgRegNumWraparound; break;
     case ErrNum_IndexedForIndirect:
       msgno = Num_ErrMsgIndexedForIndirect; break;
+    case ErrNum_NotInNormalmode:
+      msgno = Num_ErrMsgNotInNormalmode; break;
+    case ErrNum_NotInPanelmode:
+      msgno = Num_ErrMsgNotInPanelmode; break;
     case ErrNum_DoubleDef:
       msgno = Num_ErrMsgDoubleDef; break;
     case ErrNum_SymbolUndef:
@@ -652,6 +656,12 @@ static const char *ErrorNum2String(tErro
       msgno = Num_ErrMsgUnknownBitBltOpt; break;
     case ErrNum_InvCBAR:
       msgno = Num_ErrMsgInvCBAR; break;
+    case ErrNum_InAccPageErr:
+      msgno = Num_ErrMsgInAccPageErr; break;
+    case ErrNum_InAccFieldErr:
+      msgno = Num_ErrMsgInAccFieldErr; break;
+    case ErrNum_InvCombination:
+      msgno = Num_ErrMsgInvCombination; break;
     case ErrNum_InternalError:
       msgno = Num_ErrMsgInternalError; break;
     case ErrNum_OpeningFile:
diff -upNr asl-1.42b226/code6100.c asl-1.42b226-im6100/code6100.c
--- asl-1.42b226/code6100.c	1970-01-01 09:00:00.000000000 +0900
+++ asl-1.42b226-im6100/code6100.c	2022-07-27 12:52:58.225595923 +0900
@@ -0,0 +1,825 @@
+/* code6100.c */
+/*****************************************************************************/
+/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
+/*                                                                           */
+/* AS-Portierung                                                             */
+/*                                                                           */
+/* Codegenerator Intersil IM6100                                             */
+/*                                                                           */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <ctype.h>
+#include <string.h>
+
+#include "nls.h"
+#include "strutil.h"
+#include "chunks.h"
+#include "asmdef.h"
+#include "asmsub.h"
+#include "asmpars.h"
+#include "asmallg.h"
+#include "asmitree.h"
+#include "codevars.h"
+#include "codepseudo.h"
+#include "headids.h"
+#include "errmsg.h"
+#include "onoff_common.h"
+
+#include "code6100.h"
+
+/*---------------------------------------------------------------------------*/
+
+static CPUVar CPU6100;
+static CPUVar CPU6120;
+
+static PInstTable InstTableOP[3]; /* Operate Instruction */
+static Boolean BaseInst;
+
+static const Word Inst6120 =  0x8000;
+static const Word PanelOnly = 0x4000;
+static const Word NormOnly =  0x2000;
+
+#define F_6120  0x0001
+
+#define F_Norm  0x0040	/* Normal mode only */
+#define F_Panel 0x0080	/* Panel mode only */
+#define F_Combi 0x1000
+#define F_GP1   0x0800
+#define F_GP2   0x0400
+#define F_GP3   0x0200
+#define F_GP(n) (0x0800>>(n))
+
+static LongInt IBVal;
+
+static Boolean PanelMode;
+static unsigned int mregistered = 0;
+
+static ASSUMERec ASSUME6100[] =
+{
+	{"IB", &IBVal, 0, 7, 0xff, NULL},
+};
+
+static void DecodeMR(Word Index);
+static void DecodeOP(Word Index);
+static void DecodeIOT(Word Index);
+static void DecodeFix(Word Index);
+static void DecodeMEI(Word Index);
+static void DecodeRadix(Word Index);
+static void DecodeDC(Word Index);
+static void DecodeDS(Word Index);
+static void DecodeLTORG(Word Index);
+
+typedef struct {
+	char *NName;
+	InstProc Proc;
+	Word NCode[3];
+	Word Flags;
+} tInstInfo;
+
+static tInstInfo InstInfo[] = {
+	/* Memory Reference Instruction */
+	{"AND", DecodeMR, {00000,     0,     0}, 0},
+	{"TAD", DecodeMR, {01000,     0,     0}, 0},
+	{"ISZ", DecodeMR, {02000,     0,     0}, 0},
+	{"DCA", DecodeMR, {03000,     0,     0}, 0},
+	{"JMS", DecodeMR, {04000,     0,     0}, 0},
+	{"JMP", DecodeMR, {05000,     0,     0}, 0},
+
+	/* Operate Instruction (Group 1) */
+	{"NOP", DecodeOP, {07000, 07400, 07401}, F_Combi | F_GP1 | F_GP2 | F_GP3},
+	{"IAC", DecodeOP, {07001,     0,     0}, F_Combi | F_GP1},
+	{"RAL", DecodeOP, {07004,     0,     0}, F_Combi | F_GP1},
+	{"RTL", DecodeOP, {07006,     0,     0}, F_Combi | F_GP1},
+	{"R3L", DecodeOP, {07014,     0,     0}, F_6120 | F_Combi | F_GP1},
+	{"RAR", DecodeOP, {07010,     0,     0}, F_Combi | F_GP1},
+	{"RTR", DecodeOP, {07012,     0,     0}, F_Combi | F_GP1},
+	{"BSW", DecodeOP, {07002,     0,     0}, F_Combi | F_GP1},
+	{"CML", DecodeOP, {07020,     0,     0}, F_Combi | F_GP1},
+	{"CMA", DecodeOP, {07040,     0,     0}, F_Combi | F_GP1},
+	{"CIA", DecodeOP, {07041,     0,     0}, F_Combi | F_GP1},
+	{"CLL", DecodeOP, {07100,     0,     0}, F_Combi | F_GP1},
+	{"STL", DecodeOP, {07120,     0,     0}, F_Combi | F_GP1},
+	{"CLA", DecodeOP, {07200, 07600, 07601}, F_Combi | F_GP1 | F_GP2 | F_GP3},
+	{"GLK", DecodeOP, {07204,     0,     0}, F_Combi | F_GP1},
+	{"GLT", DecodeOP, {07204,     0,     0}, F_Combi | F_GP1},	/* Some documents say "GLT" */
+	{"STA", DecodeOP, {07240,     0,     0}, F_Combi | F_GP1},
+
+	/* Operate Instruction (Group 2) */
+	{"HLT", DecodeOP, {    0, 07402,     0}, F_Combi | F_GP2},
+	{"OSR", DecodeOP, {    0, 07404,     0}, F_Combi | F_GP2},
+	{"SKP", DecodeOP, {    0, 07410,     0}, F_Combi | F_GP2},
+	{"SNL", DecodeOP, {    0, 07420,     0}, F_Combi | F_GP2},
+	{"SZL", DecodeOP, {    0, 07430,     0}, F_Combi | F_GP2},
+	{"SZA", DecodeOP, {    0, 07440,     0}, F_Combi | F_GP2},
+	{"SNA", DecodeOP, {    0, 07450,     0}, F_Combi | F_GP2},
+	{"SMA", DecodeOP, {    0, 07500,     0}, F_Combi | F_GP2},
+	{"SPA", DecodeOP, {    0, 07510,     0}, F_Combi | F_GP2},
+	{"LAS", DecodeOP, {    0, 07604,     0}, F_Combi | F_GP2},
+
+	/* Operate Instruction (Group 3) */
+	{"MQL", DecodeOP, {    0,     0, 07421}, F_Combi | F_GP3},
+	{"MQA", DecodeOP, {    0,     0, 07501}, F_Combi | F_GP3},
+	{"SWP", DecodeOP, {    0,     0, 07521}, F_Combi | F_GP3},
+	{"CAM", DecodeOP, {    0,     0, 07621}, F_Combi | F_GP3},
+	{"ACL", DecodeOP, {    0,     0, 07701}, F_Combi | F_GP3},
+
+	/* I/O Transfer Instruction */
+	{"IOT", DecodeIOT, {06000,     0,     0}, 0},
+	{"SKON", DecodeFix, {06000,     0,     0}, F_Norm},
+	{"ION", DecodeFix, {06001,     0,     0}, 0},
+	{"IOF", DecodeFix, {06002,     0,     0}, 0},
+	{"SRQ", DecodeFix, {06003,     0,     0}, F_Norm},
+	{"GTF", DecodeFix, {06004,     0,     0}, F_Norm},
+	{"RTF", DecodeFix, {06005,     0,     0}, 0},
+	{"SGT", DecodeFix, {06006,     0,     0}, 0},
+	{"CAF", DecodeFix, {06007,     0,     0}, 0},
+
+	/* Stack Operation Instruction (6120 only) */
+	{"PPC1", DecodeFix, {06205,    0,     0}, F_6120},
+	{"PPC2", DecodeFix, {06245,    0,     0}, F_6120},
+	{"PAC1", DecodeFix, {06215,    0,     0}, F_6120},
+	{"PAC2", DecodeFix, {06255,    0,     0}, F_6120},
+	{"RTN1", DecodeFix, {06225,    0,     0}, F_6120},
+	{"RTN2", DecodeFix, {06265,    0,     0}, F_6120},
+	{"POP1", DecodeFix, {06235,    0,     0}, F_6120},
+	{"POP2", DecodeFix, {06275,    0,     0}, F_6120},
+	{"RSP1", DecodeFix, {06207,    0,     0}, F_6120},
+	{"RSP2", DecodeFix, {06227,    0,     0}, F_6120},
+	{"LSP1", DecodeFix, {06217,    0,     0}, F_6120},
+	{"LSP2", DecodeFix, {06237,    0,     0}, F_6120},
+
+	/* Internal Control Instruction */
+	{"WSR", DecodeFix, {06246,    0,     0}, F_6120},
+	{"GCF", DecodeFix, {06256,    0,     0}, F_6120},
+
+	/* Main Memory Control Instruction (6120 only) */
+	{"PR0", DecodeFix, {06206,    0,     0}, F_6120 | F_Norm},
+	{"PR1", DecodeFix, {06216,    0,     0}, F_6120 | F_Norm},
+	{"PR2", DecodeFix, {06226,    0,     0}, F_6120 | F_Norm},
+	{"PR3", DecodeFix, {06236,    0,     0}, F_6120 | F_Norm},
+
+	/* Panel Mode Instruction */
+	{"PRS", DecodeFix, {06000,    0,     0}, F_Panel},
+	{"PG0", DecodeFix, {06003,    0,     0}, F_Panel},
+	{"PEX", DecodeFix, {06004,    0,     0}, F_Panel},
+	{"CPD", DecodeFix, {06266,    0,     0}, F_Panel},
+	{"SPD", DecodeFix, {06276,    0,     0}, F_Panel},
+
+	/* Memory Extension Instruction */
+	{"CDF", DecodeMEI, {06201,    0,     0}, F_6120},
+	{"CIF", DecodeMEI, {06202,    0,     0}, F_6120},
+	{"RDF", DecodeFix, {06214,    0,     0}, F_6120},
+	{"RIF", DecodeFix, {06224,    0,     0}, F_6120},
+	{"RIB", DecodeFix, {06234,    0,     0}, F_6120},
+	{"RMF", DecodeFix, {06244,    0,     0}, F_6120},
+
+	/* Pseudo Instruction */
+	{"DECIMAL", DecodeRadix, {10,  0,  0}, 0},
+	{"OCTAL",   DecodeRadix, { 8,  0,  0}, 0},
+	{"DC",      DecodeDC,    { 0,  0,  0}, 0},
+	{"DS",      DecodeDS,    { 0,  0,  0}, 0},
+	{"LTORG",   DecodeLTORG, { 0,  0,  0}, 0},
+};
+
+typedef struct _TLiteral
+{
+	struct _TLiteral *Next;
+	Word Value;
+	Word FCount;
+	Boolean IsForward;
+	Integer PassNo;
+} *PLiteral, TLiteral;
+
+static PLiteral FirstLiteral;
+static LongInt ForwardCount;
+
+/*---------------------------------------------------------------------------*/
+
+static Boolean ChkValidInst(Word Index)
+{
+	Word Flags = InstInfo[Index].Flags;
+
+	if (!(Flags & F_Combi) && !BaseInst)
+	{
+		WrError(ErrNum_InvCombination);
+		return False;
+	}
+
+	if (Flags & F_6120)
+	{
+		if (MomCPU < CPU6120)
+		{
+			WrError(ErrNum_InstructionNotSupported);
+			return False;
+		}
+	}
+
+	if (Flags & F_Panel)
+	{
+		if (!PanelMode)
+		{
+			WrError(ErrNum_NotInNormalmode);
+		}
+	}
+	if (Flags & F_Norm)
+	{
+		if (PanelMode)
+		{
+			WrError(ErrNum_NotInPanelmode);
+		}
+	}
+
+	return True;
+}
+
+static char *LiteralName(PLiteral Lit, char *Result, int ResultSize)
+{
+	as_snprintf(Result, ResultSize, "LITERAL_");
+	if (Lit->IsForward)
+		as_snprcatf(Result, ResultSize, "F_%03x", Lit->FCount);
+	else
+		as_snprcatf(Result, ResultSize, "W_%03x", Lit->Value);
+	as_snprcatf(Result, ResultSize, "_%x", (unsigned)Lit->PassNo);
+	return Result;
+}
+
+/*---------------------------------------------------------------------------*/
+
+static void DecodeMR(Word Index)
+{
+	Boolean Indirect = False;
+	Boolean CurrPage = True;
+	Boolean Literal = False;
+	Word adrPos = 1;
+	Integer Adr;
+	Boolean OK;
+	tSymbolFlags Flags;
+	Word NCode = InstInfo[Index].NCode[0];
+
+	if (!ChkValidInst(Index)) return;
+
+	if (!ChkArgCnt(1,2)) return;
+
+	if (ArgCnt == 2)
+	{
+		int i;
+
+		for (i = 0; i < strlen(ArgStr[1].str.p_str); i++)
+		{
+			switch (as_toupper(ArgStr[1].str.p_str[i]))
+			{
+			case 'I':
+				Indirect = True;
+				break;
+			case 'Z':
+				CurrPage = False;
+				break;
+			case 'L':
+				Literal = True;
+				break;
+			default:
+				WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
+				return;
+			}
+		}
+		if (!CurrPage && Literal)
+		{
+			WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
+			return;
+		}
+		if (Literal && !Indirect && (NCode == 02000 || NCode == 03000))
+		{
+			WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
+			return;
+		}
+		adrPos = 2;
+	}
+
+	Adr = EvalStrIntExpressionWithFlags(&ArgStr[adrPos], Int16, &OK, &Flags);
+	if (!OK) return;
+
+	if (Literal)
+	{
+		Boolean Critical = mFirstPassUnknown(Flags) || mUsesForwards(Flags);
+		tStrComp LComp;
+		String LStr;
+		PLiteral Curr;
+		PLiteral Last;
+		Boolean Found;
+		String Name;
+		Boolean LDef;
+		
+		if (!mFirstPassUnknownOrQuestionable(Flags) && !ChkRange(Adr, -2048, 4095)) return;
+
+		StrCompMkTemp(&LComp, LStr, sizeof(LStr));
+
+		/* Already available ? */
+		Curr = FirstLiteral;
+		Last = NULL;
+		Found = False;
+		while (Curr && !Found)
+		{
+			Last = Curr;
+			if (!Critical && !Curr->IsForward)
+			{
+				if (Adr == Curr->Value) Found = True;
+			}
+			if (!Found)
+				Curr = Curr->Next;
+		}
+
+		/* Create */
+		if (!Found)
+		{
+			Curr = (PLiteral)malloc(sizeof(TLiteral));
+			Curr->Value = Adr;
+			Curr->IsForward = Critical;
+			if (Critical)
+				Curr->FCount = ForwardCount++;
+			Curr->Next = NULL;
+			Curr->PassNo = 1;
+			do
+			{
+				tStrComp LStrComp;
+
+				as_snprintf(LComp.str.p_str, STRINGSIZE, "%s[PARENT0]", LiteralName(Curr, Name, sizeof(Name)));
+				StrCompMkTemp(&LStrComp, LStr, sizeof(LStr));
+				LDef = IsSymbolDefined(&LStrComp);
+				if (LDef) Curr->PassNo++;
+			}
+			while (LDef);
+			if (!Last)
+				FirstLiteral = Curr;
+			else
+				Last->Next = Curr;
+		}
+		as_snprintf(LComp.str.p_str, STRINGSIZE, "%s[PARENT0]", LiteralName(Curr, Name, sizeof(Name)));
+		Adr = EvalStrIntExpressionWithFlags(&LComp, UInt12, &OK, &Flags);
+		if (!OK) return;
+
+		Adr |= EProgCounter() & 070000; /* Add current field to pass checks */
+	}
+
+	if (!mFirstPassUnknownOrQuestionable(Flags))
+	{
+		if (!ChkRange(Adr, 0, 32767)) return;
+
+		if ((NCode == 04000 || NCode == 05000) && !Indirect)
+		{
+			if (IBVal == ASSUME6100[0].NothingVal)
+			{
+				if ((Adr & 070000) != (EProgCounter() & 070000))
+				{
+					/* Address not in current field */
+					WrError(ErrNum_InAccFieldErr);
+					return;
+				}
+			}
+			else
+			{
+				if ((Adr & 070000) != (IBVal << 12))
+				{
+					/* Address not in IB field */
+					WrError(ErrNum_InAccFieldErr);
+					return;
+				}
+			}
+		}
+		else
+		{
+			if ((Adr & 070000) != (EProgCounter() & 070000))
+			{
+				/* Address not in current field */
+				WrError(ErrNum_InAccFieldErr);
+				return;
+			}
+		}
+
+		if (!CurrPage && (Adr & 07600))
+		{
+			/* Not in ZERO page */
+			WrError(ErrNum_InAccPageErr);
+			return;
+		}
+		if (!(Adr & 07600))
+		{
+			/* Zero page */
+			CurrPage = False;
+		}
+		else if ((Adr & 07600) != (EProgCounter() & 07600))
+		{
+			/* Not in current page */
+			WrError(ErrNum_InAccPageErr);
+			return;
+		}
+	}
+
+	WAsmCode[0] = NCode | (Indirect ? 00400 : 0) | (CurrPage ? 00200 : 0) | (Adr & 00177);
+	CodeLen = 1;
+}
+
+static Word CCode[3];
+
+static void DecodeOP(Word Index)
+{
+	Word i;
+	Word Flags = InstInfo[Index].Flags;
+
+	if (!ChkValidInst(Index)) return;
+
+	if (BaseInst)
+	{
+		for (i = 0; i < 3; i++) CCode[i] = 0;
+		if (Flags & F_GP1) CCode[0] = InstInfo[Index].NCode[0];
+		if (Flags & F_GP2) CCode[1] = InstInfo[Index].NCode[1];
+		if (Flags & F_GP3) CCode[2] = InstInfo[Index].NCode[2];
+
+		BaseInst = False;
+		for (i = 1; i <= ArgCnt; i++)
+		{
+			if (!LookupInstTable(InstTable, ArgStr[i].str.p_str))
+			{
+				WrError(ErrNum_UnknownInstruction);
+				return;
+			}
+		}
+		for (i = 0; i < 3; i++)
+		{
+			if (CCode[i])
+			{
+				WAsmCode[0] = CCode[i];
+				CodeLen = 1;
+				return;
+			}
+		}
+		WrError(ErrNum_InvCombination);
+		return;
+	}
+	else
+	{
+		Word NCode;
+		Word tmp;
+
+		for( i = 0; i < 3; i++)
+		{
+			if (!CCode[i]) continue;
+
+			if (!(Flags & F_GP(i)))
+			{
+				CCode[i] = 0;
+				continue;
+			}
+
+			NCode = InstInfo[Index].NCode[i];
+
+			tmp = CCode[i] | NCode;
+			if (tmp == CCode[i] || tmp == NCode)
+			{
+				CCode[i] = 0;
+				return;
+			}
+			if ((tmp & 00016) == 00016 )
+			{
+				CCode[i] = 0;
+				return;
+			}
+
+			switch (i)
+			{
+			case 0:
+				if ((CCode[i] & 00016) && (NCode & 00016))
+				{
+					CCode[0] = 0;
+					return;
+				}
+				break;
+			case 1:
+				if ((CCode[i] & 00160) && (NCode & 00160) && ((CCode[i] & 00010) != (NCode & 00010)))
+				{
+					CCode[i] = 0;
+					return;
+				}
+				break;
+			}
+
+			CCode[i] = tmp;
+		}
+	}
+}
+
+static void DecodeIOT(Word Index)
+{
+	Word dev;
+	Word opr;
+	Boolean OK;
+	Word NCode = InstInfo[Index].NCode[0];
+
+	if (!ChkValidInst(Index)) return;
+
+	if (!ChkArgCnt(2,2)) return;
+
+	dev = EvalStrIntExpression(&ArgStr[1], UInt6, &OK);
+	if (!OK) return;
+
+	opr = EvalStrIntExpression(&ArgStr[2], UInt3, &OK);
+	if (!OK) return;
+
+	WAsmCode[0] = NCode | (dev << 3) | opr;
+	CodeLen = 1;
+}
+
+static void DecodeFix(Word Index)
+{
+	Word NCode = InstInfo[Index].NCode[0];
+
+	if (!ChkValidInst(Index)) return;
+
+	if (!ChkArgCnt(0,0)) return;
+
+	WAsmCode[0] = NCode;
+	CodeLen = 1;
+}
+
+static void DecodeMEI(Word Index)
+{
+	int fieldPos = 1;
+	Word field;
+	Boolean OK;
+	Word NCode = InstInfo[Index].NCode[0];
+
+	if (!ChkValidInst(Index)) return;
+
+	if (!ChkArgCnt(1,2)) return;
+
+	if (ArgCnt == 2)
+	{
+		if ((!as_strcasecmp(OpPart.str.p_str, "CDF") && !as_strcasecmp(ArgStr[1].str.p_str, "CIF")) ||
+			(!as_strcasecmp(OpPart.str.p_str, "CIF") && !as_strcasecmp(ArgStr[1].str.p_str, "CDF")))
+		{
+			NCode = 06203;
+			fieldPos = 2;
+		}
+		else
+		{
+			WrError(ErrNum_UnknownInstruction);
+			return;
+		}
+	}
+
+	field = EvalStrIntExpression(&ArgStr[fieldPos], UInt3, &OK);
+	if (!OK) return;
+
+	WAsmCode[0] = NCode | (field << 3);
+	CodeLen = 1;
+}
+
+static void DecodeRadix(Word Index)
+{
+	if (!ChkArgCnt(0,0)) return;
+
+	RadixBase = InstInfo[Index].NCode[0];
+}
+
+static Boolean DecodeConst(tStrComp *pStr)
+{
+	TempResult t;
+	tSymbolFlags Flags;
+	int c;
+
+	EvalStrExpression(pStr, &t);
+	Flags = t.Flags;
+	switch(t.Typ)
+	{
+	case TempInt:
+		if (!mFirstPassUnknownOrQuestionable(Flags))
+			if (!ChkRange(t.Contents.Int, -2048, 4095)) break;
+
+		WAsmCode[CodeLen++] = t.Contents.Int & 07777;
+		break;
+	case TempString:
+		as_chartrans_xlate_nonz_dynstr(CurrTransTable->Table, &t.Contents.str);
+		for (c = 0; c < (int)t.Contents.str.len; c++)
+		{
+			WAsmCode[CodeLen++] = t.Contents.str.p_str[c] & 07777;
+		}
+		break;
+	default:
+		return False;
+	}
+
+	return True;
+}
+
+static void DecodeDC(Word Index)
+{
+	Boolean result = True;
+	int i;
+
+	UNUSED(Index);
+
+	for (i = 1; i <=ArgCnt; i++)
+	{
+		if (result)
+		{
+			result = DecodeConst(&ArgStr[i]);
+		}
+	}
+
+	if (!result) CodeLen = 0;
+}
+
+static void DecodeDS(Word Index)
+{
+	Boolean OK;
+	tSymbolFlags Flags;
+	Word Val;
+
+	UNUSED(Index);
+
+	if (!ChkArgCnt(1,1)) return;
+
+	Val = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt12, &OK, &Flags);
+	if (!OK) return;
+	if (mFirstPassUnknown(Flags))
+	{
+		WrStrErrorPos(ErrNum_FirstPassCalc, &ArgStr[1]);
+		return;
+	}
+
+	DontPrint = True;
+	CodeLen = Val;
+	BookKeeping();
+}
+
+static void DecodeLTORG(Word Index)
+{
+	PLiteral Curr, Tmp, Last;
+	String Name;
+	tStrComp TmpComp;
+
+	UNUSED(Index);
+
+	if (!ChkArgCnt(0,0)) return;
+
+	Curr = FirstLiteral;
+	while (Curr)
+	{
+		WAsmCode[CodeLen] = Curr->Value & 07777;
+		LiteralName(Curr, Name, sizeof(Name));
+		StrCompMkTemp(&TmpComp, Name, sizeof(Name));
+		EnterIntSymbol(&TmpComp, EProgCounter() + CodeLen, SegCode, False);
+		Curr->PassNo = -1;
+		CodeLen++;
+		Curr = Curr->Next;
+	}
+
+	Curr = FirstLiteral;
+	Last = NULL;
+	while (Curr)
+	{
+		if (Curr->PassNo < 0)
+		{
+			Tmp = Curr->Next;
+			if (!Last)
+				FirstLiteral = Tmp;
+			else
+				Last->Next = Tmp;
+			free(Curr);
+			Curr = Tmp;
+		}
+		else
+		{
+			Last = Curr;
+			Curr = Curr->Next;
+		}
+	}
+}
+
+static Boolean DecodeDefault(tStrComp *OpStr)
+{
+	Boolean result;
+	int i;
+
+	result = DecodeConst(OpStr);
+
+	for (i = 1; i <=ArgCnt; i++)
+	{
+		if (result)
+		{
+			result = DecodeConst(&ArgStr[i]);
+		}
+	}
+
+	if (!result) CodeLen = 0;
+
+	return result;
+}
+
+/*---------------------------------------------------------------------------*/
+
+static void InitFields(void)
+{
+	int i;
+
+	InstTable = CreateInstTable(96);
+
+	for (i = 0; i < sizeof(InstInfo)/sizeof(InstInfo[0]); i++)
+	{
+		AddInstTable(InstTable, InstInfo[i].NName, i, InstInfo[i].Proc);
+	}
+}
+
+static void DeinitFields(void)
+{
+	DestroyInstTable(InstTable);
+}
+
+/*---------------------------------------------------------------------------*/
+
+static void MakeCode_6100(void)
+{
+	int i;
+	Boolean Match = False;
+
+	CodeLen = 0;
+	DontPrint = False;
+
+	if (Memo("")) return;
+
+	BaseInst = True;
+	if (!LookupInstTable(InstTable, OpPart.str.p_str))
+		WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
+}
+
+static void InitCode_6100(void)
+{
+	mregistered = 0;
+
+	IBVal = 0;
+
+	FirstLiteral = NULL;
+	ForwardCount = 0;
+}
+
+static Boolean IsDef_6100(void)
+{
+	return False;
+}
+
+static void SwitchFrom_6100(void)
+{
+	DeinitFields();
+
+	if (FirstLiteral)
+		WrError(ErrNum_MsgMissingLTORG);
+}
+
+static void SwitchTo_6100(void)
+{
+	const TFamilyDescr *pDescr;
+
+	TurnWords = True;
+	SetIntConstMode(eIntConstModeC);
+
+	pDescr = FindFamilyByName("IM6100");
+	PCSymbol = ".";
+	HeaderID = pDescr->Id;
+	NOPCode = 0x7000;
+	DivideChars = " \t";
+	HasAttrs = False;
+
+	ValidSegs = (1 << SegCode);
+	Grans[SegCode] = 2;
+	ListGrans[SegCode] = 2;
+	SegInits[SegCode] = 0x0000;
+	if (MomCPU >= CPU6120)
+		SegLimits[SegCode] = 0x7fff;
+	else
+		SegLimits[SegCode] = 0x0fff;
+
+	if (!(mregistered & (1 << 0)))
+	{
+		mregistered |= (1 << 0);
+		SetFlag(&PanelMode, "INPANEL", False);
+	}
+	AddONOFF("PANEL", &PanelMode, "INPANEL", False);
+
+	pASSUMERecs = ASSUME6100;
+	ASSUMERecCnt = 1;
+
+	MakeCode = MakeCode_6100;
+	IsDef = IsDef_6100;
+	SwitchFrom = SwitchFrom_6100;
+	InitFields();
+}
+
+void code6100_init(void)
+{
+	CPU6100 = AddCPU("6100", SwitchTo_6100);
+	CPU6120 = AddCPU("6120", SwitchTo_6100);
+
+	AddInitPassProc(InitCode_6100);
+
+	AddCopyright("Intersil IM6100 Generator (C) 2022 Haruo Asano");
+}
diff -upNr asl-1.42b226/code6100.h asl-1.42b226-im6100/code6100.h
--- asl-1.42b226/code6100.h	1970-01-01 09:00:00.000000000 +0900
+++ asl-1.42b226-im6100/code6100.h	2022-07-14 20:53:51.029513835 +0900
@@ -0,0 +1,14 @@
+#ifndef _CODE6100_H
+#define _CODE6100_H
+/* code6100.h */
+/*****************************************************************************/
+/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
+/*                                                                           */
+/* AS-Portierung                                                             */
+/*                                                                           */
+/* Codegenerator Intersil IM6100                                             */
+/*                                                                           */
+/*****************************************************************************/
+
+extern void code6100_init(void);
+#endif /* _CODE6100_H */
diff -upNr asl-1.42b226/errmsg.h asl-1.42b226-im6100/errmsg.h
--- asl-1.42b226/errmsg.h	2022-06-11 17:51:00.000000000 +0900
+++ asl-1.42b226-im6100/errmsg.h	2022-07-20 23:13:36.534937178 +0900
@@ -59,6 +59,8 @@ typedef enum
   ErrNum_PaddingAdded = 360,
   ErrNum_RegNumWraparound = 370,
   ErrNum_IndexedForIndirect = 380,
+  ErrNum_NotInNormalmode = 390,
+  ErrNum_NotInPanelmode = 400,
   ErrNum_DoubleDef = 1000,
   ErrNum_SymbolUndef = 1010,
   ErrNum_InvSymName = 1020,
@@ -260,6 +262,9 @@ typedef enum
   ErrNum_ConfBitBltOpt = 2254,
   ErrNum_UnknownBitBltOpt = 2255,
   ErrNum_InvCBAR = 2260,
+  ErrNum_InAccPageErr = 2270,
+  ErrNum_InAccFieldErr = 2280,
+  ErrNum_InvCombination = 2290,
   ErrNum_InternalError = 10000,
   ErrNum_OpeningFile = 10001,
   ErrNum_ListWrError = 10002,
diff -upNr asl-1.42b226/headids.c asl-1.42b226-im6100/headids.c
--- asl-1.42b226/headids.c	2022-07-10 23:09:21.000000000 +0900
+++ asl-1.42b226-im6100/headids.c	2022-07-14 20:53:51.029677238 +0900
@@ -124,6 +124,7 @@ static const TFamilyDescr Descrs[] =
   { "1750"         , 0x004f, eHexFormatIntel   },
   { "CP1600"       , 0x000a, eHexFormatIntel   },
   { "NANO"         , 0x000b, eHexFormatIntel   },
+  { "IM6100"       , 0x000c, eHexFormatIntel   },
   { NULL           , 0xffff, eHexFormatDefault }
 };
 
diff -upNr asl-1.42b226/makedefs.src asl-1.42b226-im6100/makedefs.src
--- asl-1.42b226/makedefs.src	2022-07-10 23:11:59.000000000 +0900
+++ asl-1.42b226-im6100/makedefs.src	2022-07-14 20:53:51.030239563 +0900
@@ -108,7 +108,8 @@ CODE_OBJECTS = \
  $(TARG_OBJDIR)code1750$(TARG_OBJEXTENSION) \
  $(TARG_OBJDIR)codekenbak$(TARG_OBJEXTENSION) \
  $(TARG_OBJDIR)codecp1600$(TARG_OBJEXTENSION) \
- $(TARG_OBJDIR)codenano$(TARG_OBJEXTENSION)
+ $(TARG_OBJDIR)codenano$(TARG_OBJEXTENSION) \
+ $(TARG_OBJDIR)code6100$(TARG_OBJEXTENSION)
 
 DECODE_OBJECTS = \
  $(TARG_OBJDIR)deco68$(TARG_OBJEXTENSION) \
@@ -861,6 +862,11 @@ $(TARG_OBJDIR)codenano$(TARG_OBJEXTENSIO
 $(TARG_OBJDIR)codenano.dep: $(MKDEPENDTARGET)
 	$(CURRDIR)$(MKDEPENDTARGET) -r -c $(TARG_OBJEXTENSION) -o $@ $(TARG_OBJDIR)codenano$(TARG_OBJEXTENSION)
 
+$(TARG_OBJDIR)code6100$(TARG_OBJEXTENSION) : code6100.c
+	$(TARG_CC) $(ALLFLAGS) -o$(OBLANK)$@ -c code6100.c
+$(TARG_OBJDIR)code6100.dep: $(MKDEPENDTARGET)
+	$(CURRDIR)$(MKDEPENDTARGET) -r -c $(TARG_OBJEXTENSION) -o $@ $(TARG_OBJDIR)code6100$(TARG_OBJEXTENSION)
+
 $(TARG_OBJDIR)deco68$(TARG_OBJEXTENSION) : deco68.c
 	$(TARG_CC) $(ALLFLAGS) -o$(OBLANK)$@ -c deco68.c
 $(TARG_OBJDIR)deco68.dep: $(MKDEPENDTARGET)
diff -upNr asl-1.42b226/tests/t_6100/asflags asl-1.42b226-im6100/tests/t_6100/asflags
--- asl-1.42b226/tests/t_6100/asflags	1970-01-01 09:00:00.000000000 +0900
+++ asl-1.42b226-im6100/tests/t_6100/asflags	2022-07-14 22:44:56.811813634 +0900
@@ -0,0 +1 @@
+-L -n -listradix 8
\ No newline at end of file
diff -upNr asl-1.42b226/tests/t_6100/t_6100.asm asl-1.42b226-im6100/tests/t_6100/t_6100.asm
--- asl-1.42b226/tests/t_6100/t_6100.asm	1970-01-01 09:00:00.000000000 +0900
+++ asl-1.42b226-im6100/tests/t_6100/t_6100.asm	2022-07-26 22:23:40.412598754 +0900
@@ -0,0 +1,186 @@
+
+	CPU	6100
+
+	ORG	00000
+
+	NOP
+	NOP
+
+	JMP	I ZLABEL
+	NOP
+ZLABEL:	DC	TOP
+
+	ORG	.+8
+
+	ORG	01000
+
+	;;
+	;; Intersil IM6100
+	;;
+
+TOP:
+	;; Memory Reference Instruction
+	AND	CLABEL
+	TAD	ZLABEL
+	ISZ	I CLABEL
+	DCA	I ZLABEL
+	JMS	CLABEL
+	JMP	ZLABEL
+
+	;; Operate Instruction (Group 1)
+	NOP
+	IAC
+	BSW
+	RAL
+	RTL
+	RAR
+	RTR
+	EXPECT 1500
+	R3L			; 6120 only
+	ENDEXPECT
+	CML
+	CMA
+	CIA
+	CLL
+	CLL RAL
+	CLL RTL
+	CLL RAR
+	CLL RTR
+	STL
+	CLA
+	CLA IAC
+	GLK
+	STA
+	CLA CLL
+
+	;; Operate Instruction (Group 2)
+	;; NOP
+	HLT
+	OSR
+	SKP
+	SNL
+	SZL
+	SZA
+	SNA
+	SZA SNL
+	SNA SZL
+	SMA
+	SPA
+	SMA SNL
+	SPA SZL
+	SMA SZA
+	SPA SNA
+	SMA SZA SNL
+	SPA SNA SZL
+	;; CLA
+	LAS
+	SZA CLA
+	SNA CLA
+	SMA CLA
+	SPA CLA
+
+	;; Operate Instruction (Group 3)
+	;; NOP
+	MQL
+	MQA
+	SWP
+	CLA
+	CAM
+	ACL
+	CLA SWP
+
+CLABEL:	DC	07777
+
+	;; I/O Transfer Instruction
+	IOT	63 7
+	SKON
+	ION
+	IOF
+	SRQ
+	GTF
+	RTF
+	SGT
+	CAF
+
+	PANEL	ON
+
+	EXPECT	400
+	SKON
+	ENDEXPECT
+
+	PANEL	OFF
+
+	;;
+	;; Harris HD1-6120
+	;;
+
+	CPU	6120
+
+	;; Stack Operation Instruction
+	PPC1
+	PPC2
+	PAC1
+	PAC2
+	RTN1
+	RTN2
+	POP1
+	POP2
+	RSP1
+	RSP2
+	LSP1
+	LSP2
+
+	;; Internal Control Instruction
+	WSR
+	GCF
+
+	;; Main Memory Control Instruction
+	PR0
+	PR1
+	PR2
+	PR3
+
+	;; Panel Mode Control Instruction
+	PANEL	ON
+
+	PRS
+	PG0
+	PEX
+	CPD
+	SPD
+
+	PANEL	OFF
+
+	;; Memory Extension Instruction
+	CDF	1
+	CIF	4
+	CDF CIF	6
+	RDF
+	RIF
+	RIB
+	RMF
+
+	;;
+	;; Pseudo Instruction
+	;;
+	CPU	6100
+
+	DC	07777
+	DC	"IM6100" 0xd 012
+	
+	;; DECIMAL / OCTAL
+	OCTAL
+	DC	2525
+	DECIMAL
+	DC	2525
+
+	;; LTORG
+LABB:
+	AND	L LABB
+	AND	L LABF
+	TAD	L LABG
+	TAD	L 01000
+LABF:
+	LTORG
+LABG:
+	
Binary files asl-1.42b226/tests/t_6100/t_6100.ori and asl-1.42b226-im6100/tests/t_6100/t_6100.ori differ
