diff --git a/ISA_HEX_Map.org b/ISA_HEX_Map.org
index 4663ba6..ffe84ba 100644
--- a/ISA_HEX_Map.org
+++ b/ISA_HEX_Map.org
@@ -506,6 +506,37 @@ DO NOT USE.
 |-------------+----------|
 | 43 00 00 00 | Reserved |
 | ...         | Reserved |
+| 9F FF FF FF | Reserved |
+
+** CMPSKIP Group
+| Hex         | Name        | Comment                            |
+|-------------+-------------+------------------------------------|
+| A0 0a ii ii | CMPSKIP.G   | a > ii ii ? Skip Next instruction  |
+| A0 1a ii ii | CMPSKIP.GE  | a >= ii ii ? Skip Next instruction |
+| A0 2a ii ii | CMPSKIP.E   | a == ii ii ? Skip Next instruction |
+| A0 3a ii ii | CMPSKIP.NE  | a != ii ii ? Skip Next instruction |
+| A0 4a ii ii | CMPSKIP.LE  | a <= ii ii ? Skip Next instruction |
+| A0 5a ii ii | CMPSKIP.L   | a < ii ii ? Skip Next instruction  |
+| A0 6a ii ii | Reserved    |                                    |
+| ...         | Reserved    |                                    |
+| A0 Fa ii ii | Reserved    |                                    |
+| A1 0a ii ii | CMPSKIPU.G  | a > ii ii ? Skip Next instruction  |
+| A1 1a ii ii | CMPSKIPU.GE | a >= ii ii ? Skip Next instruction |
+| A1 2a ii ii | Reserved    |                                    |
+| A1 3a ii ii | Reserved    |                                    |
+| A1 4a ii ii | CMPSKIPU.LE | a <= ii ii ? Skip Next instruction |
+| A1 5a ii ii | CMPSKIPU.L  | a < ii ii ? Skip Next instruction  |
+| A1 6a ii ii | Reserved    |                                    |
+| ...         | Reserved    |                                    |
+| A1 Fa ii ii | Reserved    |                                    |
+
+** Reserved Block 2
+At this time these instructions only produce a warning; but could do anything.
+DO NOT USE.
+| Hex         | Name     |
+|-------------+----------|
+| B0 00 00 00 | Reserved |
+| ...         | Reserved |
 | BF FF FF FF | Reserved |
 
 ** CMPJUMP Group
@@ -530,7 +561,7 @@ DO NOT USE.
 | ...         | Reserved    |                                     |
 | DF ab ii ii | Reserved    |                                     |
 
-** Reserved Block 2
+** Reserved Block 3
 At this time these instructions only produce a warning; but could do anything.
 DO NOT USE.
 | Hex         | Name     |
diff --git a/asm.c b/asm.c
index abfb954..b7a01ae 100644
--- a/asm.c
+++ b/asm.c
@@ -327,6 +327,16 @@ void assemble(struct Token* p)
 	setExpression(p, "STORER8", "2F1", 4);
 	setExpression(p, "STORER16", "2F2", 4);
 	setExpression(p, "STORER32", "2F3", 4);
+	setExpression(p, "CMPSKIP.G", "A00", 4);
+	setExpression(p, "CMPSKIP.GE", "A01", 4);
+	setExpression(p, "CMPSKIP.E", "A02", 4);
+	setExpression(p, "CMPSKIP.NE", "A03", 4);
+	setExpression(p, "CMPSKIP.LE", "A04", 4);
+	setExpression(p, "CMPSKIP.L", "A05", 4);
+	setExpression(p, "CMPSKIPU.G", "A10", 4);
+	setExpression(p, "CMPSKIPU.GE", "A11", 4);
+	setExpression(p, "CMPSKIPU.LE", "A14", 4);
+	setExpression(p, "CMPSKIPU.L", "A15", 4);
 
 	/* 0OPI Group */
 	setExpression(p, "JUMP", "3C00", 4);
diff --git a/disasm.c b/disasm.c
index 8af4f1b..943f912 100644
--- a/disasm.c
+++ b/disasm.c
@@ -845,259 +845,226 @@ void decode_1OPI(struct Instruction* c)
 	c->reg0 = c->raw1%16;
 
 	char Name[20] = "ILLEGAL_1OPI";
+	uint32_t Opcode = (c->raw0 * 16) + c->raw_XOP;
 
 	/* Convert to Human readable form */
-	switch(c->raw_XOP)
+	switch(Opcode)
 	{
-		case 0x0: /* JUMP.C */
+		case 0x2C0: /* JUMP.C */
 		{
 			strncpy(Name, "JUMP.C", 19);
 			break;
 		}
-		case 0x1: /* JUMP.B */
+		case 0x2C1: /* JUMP.B */
 		{
 			strncpy(Name, "JUMP.B", 19);
 			break;
 		}
-		case 0x2: /* JUMP.O */
+		case 0x2C2: /* JUMP.O */
 		{
 			strncpy(Name, "JUMP.O", 19);
 			break;
 		}
-		case 0x3: /* JUMP.G */
+		case 0x2C3: /* JUMP.G */
 		{
 			strncpy(Name, "JUMP.G", 19);
 			break;
 		}
-		case 0x4: /* JUMP.GE */
+		case 0x2C4: /* JUMP.GE */
 		{
 			strncpy(Name, "JUMP.GE", 19);
 			break;
 		}
-		case 0x5: /* JUMP.E */
+		case 0x2C5: /* JUMP.E */
 		{
 			strncpy(Name, "JUMP.E", 19);
 			break;
 		}
-		case 0x6: /* JUMP.NE */
+		case 0x2C6: /* JUMP.NE */
 		{
 			strncpy(Name, "JUMP.NE", 19);
 			break;
 		}
-		case 0x7: /* JUMP.LE */
+		case 0x2C7: /* JUMP.LE */
 		{
 			strncpy(Name, "JUMP.LE", 19);
 			break;
 		}
-		case 0x8: /* JUMP.L */
+		case 0x2C8: /* JUMP.L */
 		{
 			strncpy(Name, "JUMP.L", 19);
 			break;
 		}
-		case 0x9: /* JUMP.Z */
+		case 0x2C9: /* JUMP.Z */
 		{
 			strncpy(Name, "JUMP.Z", 19);
 			break;
 		}
-		case 0xA: /* JUMP.NZ */
+		case 0x2CA: /* JUMP.NZ */
 		{
 			strncpy(Name, "JUMP.NZ", 19);
 			break;
 		}
-		case 0xB: /* JUMP.P */
+		case 0x2CB: /* JUMP.P */
 		{
 			strncpy(Name, "JUMP.P", 19);
 			break;
 		}
-		case 0xC: /* JUMP.NP */
+		case 0x2CC: /* JUMP.NP */
 		{
 			strncpy(Name, "JUMP.NP", 19);
 			break;
 		}
-		default: /* Unknown 1OPI*/
-		{
-			break;
-		}
-	}
-
-	fprintf(stdout, "%s reg%u %d\t", Name, c->reg0, c->raw_Immediate);
-	fprintf(stdout, "# %s\n", c->operation);
-}
-
-void decode_Branch_1OPI(struct Instruction* c)
-{
-	/* Parse Raw Data */
-	c->raw_Immediate = c->raw2*0x100 + c->raw3;
-	c->Immediate[0] = c->operation[3];
-	c->Immediate[1] = c->operation[4];
-	c->Immediate[2] = c->operation[5];
-	c->Immediate[3] = c->operation[6];
-	c->Immediate[4] = c->operation[7];
-	c->HAL_CODE = 0;
-	c->raw_XOP = c->raw1/16;
-	c->reg0 = c->raw1%16;
-
-	char Name[20] = "ILLEGAL_1OPI";
-
-	/* Convert to Human readable form */
-	switch(c->raw_XOP)
-	{
-		case 0x0: /* CALLI */
+		case 0x2D0: /* CALLI */
 		{
 			strncpy(Name, "CALLI", 19);
 			break;
 		}
-		case 0x1: /* LOADI */
+		case 0x2D1: /* LOADI */
 		{
 			strncpy(Name, "LOADI", 19);
 			break;
 		}
-		case 0x2: /* LOADUI */
+		case 0x2D2: /* LOADUI*/
 		{
 			strncpy(Name, "LOADUI", 19);
 			break;
 		}
-		case 0x3: /* SALI */
+		case 0x2D3: /* SALI */
 		{
 			strncpy(Name, "SALI", 19);
 			break;
 		}
-		case 0x4: /* SARI */
+		case 0x2D4: /* SARI */
 		{
 			strncpy(Name, "SARI", 19);
 			break;
 		}
-		case 0x5: /* SL0I */
+		case 0x2D5: /* SL0I */
 		{
 			strncpy(Name, "SL0I", 19);
 			break;
 		}
-		case 0x6: /* SR0I */
+		case 0x2D6: /* SR0I */
 		{
 			strncpy(Name, "SR0I", 19);
 			break;
 		}
-		case 0x7: /* SL1I */
+		case 0x2D7: /* SL1I */
 		{
 			strncpy(Name, "SL1I", 19);
 			break;
 		}
-		case 0x8: /* SR1I */
+		case 0x2D8: /* SR1I */
 		{
 			strncpy(Name, "SR1I", 19);
 			break;
 		}
-		default: /* Unknown 1OPI*/
-		{
-			break;
-		}
-	}
-
-	fprintf(stdout, "%s reg%u %d\t", Name, c->reg0, c->raw_Immediate);
-	fprintf(stdout, "# %s\n", c->operation);
-}
-
-void decode_Load_1OPI(struct Instruction* c)
-{
-	/* Parse Raw Data */
-	c->raw_Immediate = c->raw2*0x100 + c->raw3;
-	c->Immediate[0] = c->operation[3];
-	c->Immediate[1] = c->operation[4];
-	c->Immediate[2] = c->operation[5];
-	c->Immediate[3] = c->operation[6];
-	c->Immediate[4] = c->operation[7];
-	c->HAL_CODE = 0;
-	c->raw_XOP = c->raw1/16;
-	c->reg0 = c->raw1%16;
-
-	char Name[20] = "ILLEGAL_1OPI";
-
-	/* Convert to Human readable form */
-	switch(c->raw_XOP)
-	{
-		case 0x0: /* LOADR */
+		case 0x2E0: /* LOADR */
 		{
 			strncpy(Name, "LOADR", 19);
 			break;
 		}
-		case 0x1: /* LOADR8 */
+		case 0x2E1: /* LOADR8 */
 		{
 			strncpy(Name, "LOADR8", 19);
 			break;
 		}
-		case 0x2: /* LOADRU8 */
+		case 0x2E2: /* LOADRU8 */
 		{
 			strncpy(Name, "LOADRU8", 19);
 			break;
 		}
-		case 0x3: /* LOADR16 */
+		case 0x2E3: /* LOADR16 */
 		{
 			strncpy(Name, "LOADR16", 19);
 			break;
 		}
-		case 0x4: /* LOADRU16 */
+		case 0x2E4: /* LOADRU16 */
 		{
 			strncpy(Name, "LOADRU16", 19);
 			break;
 		}
-		case 0x5: /* LOADR32 */
+		case 0x2E5: /* LOADR32 */
 		{
 			strncpy(Name, "LOADR32", 19);
 			break;
 		}
-		case 0x6: /* LOADRU32 */
+		case 0x2E6: /* LOADRU32 */
 		{
 			strncpy(Name, "LOADRU32", 19);
 			break;
 		}
-		default: /* Unknown 1OPI*/
-		{
-			break;
-		}
-	}
-
-	fprintf(stdout, "%s reg%u %d\t", Name, c->reg0, c->raw_Immediate);
-	fprintf(stdout, "# %s\n", c->operation);
-}
-
-void decode_Store_1OPI(struct Instruction* c)
-{
-	/* Parse Raw Data */
-	c->raw_Immediate = c->raw2*0x100 + c->raw3;
-	c->Immediate[0] = c->operation[3];
-	c->Immediate[1] = c->operation[4];
-	c->Immediate[2] = c->operation[5];
-	c->Immediate[3] = c->operation[6];
-	c->Immediate[4] = c->operation[7];
-	c->HAL_CODE = 0;
-	c->raw_XOP = c->raw1/16;
-	c->reg0 = c->raw1%16;
-
-	char Name[20] = "ILLEGAL_1OPI";
-
-	/* Convert to Human readable form */
-	switch(c->raw_XOP)
-	{
-		case 0x0: /* STORER */
+		case 0x2F0: /* STORER */
 		{
 			strncpy(Name, "STORER", 19);
 			break;
 		}
-		case 0x1: /* STORER8 */
+		case 0x2F1: /* STORER8 */
 		{
 			strncpy(Name, "STORER8", 19);
 			break;
 		}
-		case 0x2: /* STORER16 */
+		case 0x2F2: /* STORER16 */
 		{
 			strncpy(Name, "STORER16", 19);
 			break;
 		}
-		case 0x3: /* STORER32 */
+		case 0x2F3: /* STORER32 */
 		{
 			strncpy(Name, "STORER32", 19);
 			break;
 		}
+		case 0xA00: /* CMPSKIP.G */
+		{
+			strncpy(Name, "CMPSKIP.G", 19);
+			break;
+		}
+		case 0xA01: /* CMPSKIP.GE */
+		{
+			strncpy(Name, "CMPSKIP.GE", 19);
+			break;
+		}
+		case 0xA02: /* CMPSKIP.E */
+		{
+			strncpy(Name, "CMPSKIP.E", 19);
+			break;
+		}
+		case 0xA03: /* CMPSKIP.NE */
+		{
+			strncpy(Name, "CMPSKIP.NE", 19);
+			break;
+		}
+		case 0xA04: /* CMPSKIP.LE */
+		{
+			strncpy(Name, "CMPSKIP.LE", 19);
+			break;
+		}
+		case 0xA05: /* CMPSKIP.L */
+		{
+			strncpy(Name, "CMPSKIP.L", 19);
+			break;
+		}
+		case 0xA10: /* CMPSKIPU.G */
+		{
+			strncpy(Name, "CMPSKIPU.G", 19);
+			break;
+		}
+		case 0xA11: /* CMPSKIPU.GE */
+		{
+			strncpy(Name, "CMPSKIPU.GE", 19);
+			break;
+		}
+		case 0xA14: /* CMPSKIPU.LE */
+		{
+			strncpy(Name, "CMPSKIPU.LE", 19);
+			break;
+		}
+		case 0xA15: /* CMPSKIPU.L */
+		{
+			strncpy(Name, "CMPSKIPU.L", 19);
+			break;
+		}
 		default: /* Unknown 1OPI*/
 		{
 			break;
@@ -1220,32 +1187,18 @@ void eval_instruction(struct Instruction* c)
 			decode_1OP(c);
 			break;
 		}
-		case 0x0E ... 0x2B: /* Core 2OPI */
+		case 0x0E ... 0x2B: /* 2OPI */
 		case 0xC0 ... 0xDF:
 		{
 			decode_Integer_2OPI(c);
 			break;
 		}
-		case 0x2C: /* Core 1OPI */
+		case 0x2C ... 0x2F: /* 1OPI */
+		case 0xA0 ... 0xA1:
 		{
 			decode_1OPI(c);
 			break;
 		}
-		case 0x2D: /* Branch 1OPI*/
-		{
-			decode_Branch_1OPI(c);
-			break;
-		}
-		case 0x2E: /* LOADR 1OPI */
-		{
-			decode_Load_1OPI(c);
-			break;
-		}
-		case 0x2F: /* STORER 1OPI*/
-		{
-			decode_Store_1OPI(c);
-			break;
-		}
 		case 0x3C: /* Core 0OPI */
 		{
 			decode_0OPI(c);
diff --git a/vm.c b/vm.c
index 1c08502..ae6a2ac 100644
--- a/vm.c
+++ b/vm.c
@@ -162,6 +162,16 @@ void CMPJUMPU_G(struct lilith* vm, struct Instruction* c);
 void CMPJUMPU_GE(struct lilith* vm, struct Instruction* c);
 void CMPJUMPU_LE(struct lilith* vm, struct Instruction* c);
 void CMPJUMPU_L(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_G(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_GE(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_E(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_NE(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_LE(struct lilith* vm, struct Instruction* c);
+void CMPSKIP_L(struct lilith* vm, struct Instruction* c);
+void CMPSKIPU_G(struct lilith* vm, struct Instruction* c);
+void CMPSKIPU_GE(struct lilith* vm, struct Instruction* c);
+void CMPSKIPU_LE(struct lilith* vm, struct Instruction* c);
+void CMPSKIPU_L(struct lilith* vm, struct Instruction* c);
 
 /* Allocate and intialize memory/state */
 struct lilith* create_vm(size_t size)
@@ -1871,6 +1881,96 @@ bool eval_Integer_1OPI(struct lilith* vm, struct Instruction* c)
 			STORER32(vm, c);
 			break;
 		}
+		case 0xA00: /* CMPSKIP.G */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.G", 19);
+			#endif
+
+			CMPSKIP_G(vm, c);
+			break;
+		}
+		case 0xA01: /* CMPSKIP.GE */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.GE", 19);
+			#endif
+
+			CMPSKIP_GE(vm, c);
+			break;
+		}
+		case 0xA02: /* CMPSKIP.E */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.E", 19);
+			#endif
+
+			CMPSKIP_E(vm, c);
+			break;
+		}
+		case 0xA03: /* CMPSKIP.NE */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.NE", 19);
+			#endif
+
+			CMPSKIP_NE(vm, c);
+			break;
+		}
+		case 0xA04: /* CMPSKIP.LE */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.LE", 19);
+			#endif
+
+			CMPSKIP_LE(vm, c);
+			break;
+		}
+		case 0xA05: /* CMPSKIP.L */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIP.L", 19);
+			#endif
+
+			CMPSKIP_L(vm, c);
+			break;
+		}
+		case 0xA10: /* CMPSKIPU.G */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIPU.G", 19);
+			#endif
+
+			CMPSKIPU_G(vm, c);
+			break;
+		}
+		case 0xA11: /* CMPSKIPU.GE */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIPU.GE", 19);
+			#endif
+
+			CMPSKIPU_GE(vm, c);
+			break;
+		}
+		case 0xA14: /* CMPSKIPU.LE */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIPU.LE", 19);
+			#endif
+
+			CMPSKIPU_LE(vm, c);
+			break;
+		}
+		case 0xA15: /* CMPSKIPU.L */
+		{
+			#ifdef DEBUG
+			strncpy(Name, "CMPSKIPU.L", 19);
+			#endif
+
+			CMPSKIPU_L(vm, c);
+			break;
+		}
 		default: return true;
 	}
 	#ifdef DEBUG
@@ -1959,6 +2059,7 @@ void eval_instruction(struct lilith* vm, struct Instruction* current)
 			break;
 		}
 		case 0x2C ... 0x2F: /* Integer 1OPI */
+		case 0xA0 ... 0xA1:
 		{
 			decode_1OPI(current);
 			invalid = eval_Integer_1OPI(vm, current);
diff --git a/vm_instructions.c b/vm_instructions.c
index 2716e35..8d5ec91 100644
--- a/vm_instructions.c
+++ b/vm_instructions.c
@@ -1728,3 +1728,123 @@ void CMPJUMPU_L(struct lilith* vm, struct Instruction* c)
 		vm->ip = vm->ip + c->raw_Immediate - 4;
 	}
 }
+
+void CMPSKIP_G(struct lilith* vm, struct Instruction* c)
+{
+	int32_t tmp1, tmp2;
+	tmp1 = (int32_t)(vm->reg[c->reg0]);
+	tmp2 = (int32_t)(c->raw_Immediate);
+
+	if(tmp1 > tmp2)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIP_GE(struct lilith* vm, struct Instruction* c)
+{
+	int32_t tmp1, tmp2;
+	tmp1 = (int32_t)(vm->reg[c->reg0]);
+	tmp2 = (int32_t)(c->raw_Immediate);
+
+	if(tmp1 >= tmp2)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIP_E(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) == utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIP_NE(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) != utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIP_LE(struct lilith* vm, struct Instruction* c)
+{
+	int32_t tmp1, tmp2;
+	tmp1 = (int32_t)(vm->reg[c->reg0]);
+	tmp2 = (int32_t)(c->raw_Immediate);
+
+	if(tmp1 <= tmp2)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIP_L(struct lilith* vm, struct Instruction* c)
+{
+	int32_t tmp1, tmp2;
+	tmp1 = (int32_t)(vm->reg[c->reg0]);
+	tmp2 = (int32_t)(c->raw_Immediate);
+
+	if(tmp1 < tmp2)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIPU_G(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) > utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIPU_GE(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) >= utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIPU_LE(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) <= utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}
+
+void CMPSKIPU_L(struct lilith* vm, struct Instruction* c)
+{
+	uint16_t utmp1;
+
+	utmp1 = (uint16_t)(c->raw_Immediate);
+
+	if((vm->reg[c->reg0]) < utmp1)
+	{
+		vm->ip = vm->ip + 4;
+	}
+}