diff --git a/CMakeLists.txt b/CMakeLists.txt
index b4a961f..92d4ea1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,8 +28,8 @@
 option(CAPSTONE_BUILD_CSTOOL "Build cstool" ON)
 option(CAPSTONE_USE_DEFAULT_ALLOC "Use default memory allocation functions" ON)
 
-set(SUPPORTED_ARCHITECTURES ARM ARM64 M68K MIPS PPC SPARC SYSZ XCORE X86 TMS320C64X M680X EVM)
-set(SUPPORTED_ARCHITECTURE_LABELS ARM ARM64 M68K MIPS PowerPC Sparc SystemZ XCore x86 TMS320C64x M680x EVM)
+set(SUPPORTED_ARCHITECTURES ARM ARM64 M68K MIPS PPC SPARC SYSZ XCORE X86 TMS320C64X M680X EVM NEO)
+set(SUPPORTED_ARCHITECTURE_LABELS ARM ARM64 M68K MIPS PowerPC Sparc SystemZ XCore x86 TMS320C64x M680x EVM NEO)
 
 list(LENGTH SUPPORTED_ARCHITECTURES count)
 math(EXPR count "${count}-1")
@@ -382,6 +382,23 @@
     set(TEST_SOURCES ${TEST_SOURCES} test_evm.c)
 endif ()
 
+if (CAPSTONE_NEO_SUPPORT)
+    add_definitions(-DCAPSTONE_HAS_NEO)
+    set(SOURCES_NEO
+        arch/NEO/NEODisassembler.c
+        arch/NEO/NEOInstPrinter.c
+        arch/NEO/NEOMapping.c
+        arch/NEO/NEOModule.c
+    )
+    set(HEADERS_NEO
+        arch/NEO/NEODisassembler.h
+        arch/NEO/NEOInstPrinter.h
+        arch/NEO/NEOMapping.h
+        arch/NEO/NEOMappingInsn.inc
+        )
+    set(TEST_SOURCES ${TEST_SOURCES} test_neo.c)
+endif ()
+
 if (CAPSTONE_OSXKERNEL_SUPPORT)
     add_definitions(-DCAPSTONE_HAS_OSXKERNEL)
 endif ()
@@ -400,6 +417,7 @@
     ${SOURCES_TMS320C64X}
     ${SOURCES_M680X}
     ${SOURCES_EVM}
+    ${SOURCES_NEO}
     )
 
 set(ALL_HEADERS
@@ -417,6 +435,7 @@
     ${HEADERS_TMS320C64X}
     ${HEADERS_M680X}
     ${HEADERS_EVM}
+    ${HEADERS_NEO}
     )
 
 include_directories("${PROJECT_SOURCE_DIR}/include")
@@ -497,6 +516,7 @@
 source_group("Source\\TMS320C64x" FILES ${SOURCES_TMS320C64X})
 source_group("Source\\M680X" FILES ${SOURCES_M680X})
 source_group("Source\\EVM" FILES ${SOURCES_EVM})
+source_group("Source\\NEO" FILES ${SOURCES_NEO})
 
 source_group("Include\\Common" FILES ${HEADERS_COMMON})
 source_group("Include\\Engine" FILES ${HEADERS_ENGINE})
@@ -512,6 +532,7 @@
 source_group("Include\\TMS320C64x" FILES ${HEADERS_TMS320C64X})
 source_group("Include\\M680X" FILES ${HEADERS_MC680X})
 source_group("Include\\EVM" FILES ${HEADERS_EVM})
+source_group("Include\\NEO" FILES ${HEADERS_NEO})
 
 ### test library 64bit routine:
 get_property(LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)
diff --git a/COMPILE.TXT b/COMPILE.TXT
index 56aecad..9fa135e 100644
--- a/COMPILE.TXT
+++ b/COMPILE.TXT
@@ -17,12 +17,12 @@
 
 (0) Tailor Capstone to your need.
 
-  Out of 12 archtitectures supported by Capstone (Arm, Arm64, M68K, Mips, PPC,
-  Sparc, SystemZ, XCore, X86, M680X, TMS320C64x & EVM), if you just need several
-  selected archs, choose the ones you want to compile in by editing "config.mk"
-  before going to next steps.
+  Out of 13 archtitectures supported by Capstone (Arm, Arm64, M68K, Mips, PPC,
+  Sparc, SystemZ, XCore, X86, M680X, TMS320C64x, EVM & NEO), if you just need
+  several selected archs, choose the ones you want to compile in by editing
+  "config.mk" before going to next steps.
 
-  By default, all 12 architectures are compiled.
+  By default, all architectures are compiled.
 
   The other way of customize Capstone without having to edit config.mk is to
   pass the desired options on the commandline to ./make.sh. Currently,
@@ -91,6 +91,7 @@
 	/usr/include/capstone/m68k.h
 	/usr/include/capstone/m680x.h
 	/usr/include/capstone/mips.h
+	/usr/include/capstone/neo.h
 	/usr/include/capstone/ppc.h
 	/usr/include/capstone/sparc.h
 	/usr/include/capstone/systemz.h
diff --git a/HACK.TXT b/HACK.TXT
index e641c68..a7058d1 100644
--- a/HACK.TXT
+++ b/HACK.TXT
@@ -5,12 +5,15 @@
 ├── arch            <- code handling disasm engine for each arch
 │   ├── AArch64     <- ARM64 (aka ARMv8) engine
 │   ├── ARM         <- ARM engine
+│   ├── EVM         <- Ethereum VM engine
 │   ├── M680X       <- M680X engine
 │   ├── M68K        <- M68K engine
 │   ├── Mips        <- Mips engine
+│   ├── NEO         <- NEO VM engine
 │   ├── PowerPC     <- PowerPC engine
 │   ├── Sparc       <- Sparc engine
 │   ├── SystemZ     <- SystemZ engine
+│   ├── TMS320C64x  <- TMS320C64x engine
 │   ├── X86         <- X86 engine
 │   └── XCore       <- XCore engine
 ├── bindings        <- all bindings are under this dir
diff --git a/MCInst.h b/MCInst.h
index 6a70741..5516246 100644
--- a/MCInst.h
+++ b/MCInst.h
@@ -110,6 +110,7 @@
 	uint8_t popcode_adjust;   // Pseudo X86 instruction adjust
 	char assembly[8];	// for special instruction, so that we dont need printer
 	unsigned char evm_data[32];	// for EVM PUSH operand
+	unsigned char neo_data[80];	// for NEO instructions with operands
 };
 
 void MCInst_Init(MCInst *inst);
diff --git a/Makefile b/Makefile
index 0118122..0d469a7 100644
--- a/Makefile
+++ b/Makefile
@@ -250,9 +250,20 @@
 endif
 
 
+DEP_NEO =
+DEP_NEO += $(wildcard arch/NEO/NEO*.inc)
+
+LIBOBJ_NEO =
+ifneq (,$(findstring neo,$(CAPSTONE_ARCHS)))
+	CFLAGS += -DCAPSTONE_HAS_NEO
+	LIBSRC_NEO += $(wildcard arch/NEO/NEO*.c)
+	LIBOBJ_NEO += $(LIBSRC_NEO:%.c=$(OBJDIR)/%.o)
+endif
+
+
 LIBOBJ =
 LIBOBJ += $(OBJDIR)/cs.o $(OBJDIR)/utils.o $(OBJDIR)/SStream.o $(OBJDIR)/MCInstrDesc.o $(OBJDIR)/MCRegisterInfo.o
-LIBOBJ += $(LIBOBJ_ARM) $(LIBOBJ_ARM64) $(LIBOBJ_M68K) $(LIBOBJ_MIPS) $(LIBOBJ_PPC) $(LIBOBJ_SPARC) $(LIBOBJ_SYSZ) $(LIBOBJ_X86) $(LIBOBJ_XCORE) $(LIBOBJ_TMS320C64X) $(LIBOBJ_M680X) $(LIBOBJ_EVM)
+LIBOBJ += $(LIBOBJ_ARM) $(LIBOBJ_ARM64) $(LIBOBJ_M68K) $(LIBOBJ_MIPS) $(LIBOBJ_PPC) $(LIBOBJ_SPARC) $(LIBOBJ_SYSZ) $(LIBOBJ_X86) $(LIBOBJ_XCORE) $(LIBOBJ_TMS320C64X) $(LIBOBJ_M680X) $(LIBOBJ_EVM) $(LIBOBJ_NEO)
 LIBOBJ += $(OBJDIR)/MCInst.o
 
 
@@ -379,6 +390,7 @@
 $(LIBOBJ_TMS320C64X): $(DEP_TMS320C64X)
 $(LIBOBJ_M680X): $(DEP_M680X)
 $(LIBOBJ_EVM): $(DEP_EVM)
+$(LIBOBJ_NEO): $(DEP_NEO)
 
 ifeq ($(CAPSTONE_STATIC),yes)
 $(ARCHIVE): $(LIBOBJ)
diff --git a/README.md b/README.md
index e25acef..c13acad 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
 Capstone offers some unparalleled features:
 
 - Support multiple hardware architectures: ARM, ARM64 (ARMv8), Ethereum VM, M68K,
-  Mips, PPC, Sparc, SystemZ, TMS320C64X, M680X, XCore and X86 (including X86_64).
+  Mips, NEO VM, PPC, Sparc, SystemZ, TMS320C64X, M680X, XCore and X86.
 
 - Having clean/simple/lightweight/intuitive architecture-neutral API.
 
diff --git a/arch/NEO/NEODisassembler.c b/arch/NEO/NEODisassembler.c
new file mode 100644
index 0000000..0e90c70
--- /dev/null
+++ b/arch/NEO/NEODisassembler.c
@@ -0,0 +1,340 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include <string.h>
+
+#include "NEODisassembler.h"
+#include "NEOMapping.h"
+
+static short opcodes[256] = {
+	NEO_INS_PUSH0,
+	NEO_INS_PUSHBYTES1,
+	NEO_INS_PUSHBYTES2,
+	NEO_INS_PUSHBYTES3,
+	NEO_INS_PUSHBYTES4,
+	NEO_INS_PUSHBYTES5,
+	NEO_INS_PUSHBYTES6,
+	NEO_INS_PUSHBYTES7,
+	NEO_INS_PUSHBYTES8,
+	NEO_INS_PUSHBYTES9,
+	NEO_INS_PUSHBYTES10,
+	NEO_INS_PUSHBYTES11,
+	NEO_INS_PUSHBYTES12,
+	NEO_INS_PUSHBYTES13,
+	NEO_INS_PUSHBYTES14,
+	NEO_INS_PUSHBYTES15,
+	NEO_INS_PUSHBYTES16,
+	NEO_INS_PUSHBYTES17,
+	NEO_INS_PUSHBYTES18,
+	NEO_INS_PUSHBYTES19,
+	NEO_INS_PUSHBYTES20,
+	NEO_INS_PUSHBYTES21,
+	NEO_INS_PUSHBYTES22,
+	NEO_INS_PUSHBYTES23,
+	NEO_INS_PUSHBYTES24,
+	NEO_INS_PUSHBYTES25,
+	NEO_INS_PUSHBYTES26,
+	NEO_INS_PUSHBYTES27,
+	NEO_INS_PUSHBYTES28,
+	NEO_INS_PUSHBYTES29,
+	NEO_INS_PUSHBYTES30,
+	NEO_INS_PUSHBYTES31,
+	NEO_INS_PUSHBYTES32,
+	NEO_INS_PUSHBYTES33,
+	NEO_INS_PUSHBYTES34,
+	NEO_INS_PUSHBYTES35,
+	NEO_INS_PUSHBYTES36,
+	NEO_INS_PUSHBYTES37,
+	NEO_INS_PUSHBYTES38,
+	NEO_INS_PUSHBYTES39,
+	NEO_INS_PUSHBYTES40,
+	NEO_INS_PUSHBYTES41,
+	NEO_INS_PUSHBYTES42,
+	NEO_INS_PUSHBYTES43,
+	NEO_INS_PUSHBYTES44,
+	NEO_INS_PUSHBYTES45,
+	NEO_INS_PUSHBYTES46,
+	NEO_INS_PUSHBYTES47,
+	NEO_INS_PUSHBYTES48,
+	NEO_INS_PUSHBYTES49,
+	NEO_INS_PUSHBYTES50,
+	NEO_INS_PUSHBYTES51,
+	NEO_INS_PUSHBYTES52,
+	NEO_INS_PUSHBYTES53,
+	NEO_INS_PUSHBYTES54,
+	NEO_INS_PUSHBYTES55,
+	NEO_INS_PUSHBYTES56,
+	NEO_INS_PUSHBYTES57,
+	NEO_INS_PUSHBYTES58,
+	NEO_INS_PUSHBYTES59,
+	NEO_INS_PUSHBYTES60,
+	NEO_INS_PUSHBYTES61,
+	NEO_INS_PUSHBYTES62,
+	NEO_INS_PUSHBYTES63,
+	NEO_INS_PUSHBYTES64,
+	NEO_INS_PUSHBYTES65,
+	NEO_INS_PUSHBYTES66,
+	NEO_INS_PUSHBYTES67,
+	NEO_INS_PUSHBYTES68,
+	NEO_INS_PUSHBYTES69,
+	NEO_INS_PUSHBYTES70,
+	NEO_INS_PUSHBYTES71,
+	NEO_INS_PUSHBYTES72,
+	NEO_INS_PUSHBYTES73,
+	NEO_INS_PUSHBYTES74,
+	NEO_INS_PUSHBYTES75,
+	NEO_INS_PUSHDATA1,
+	NEO_INS_PUSHDATA2,
+	NEO_INS_PUSHDATA4,
+	NEO_INS_PUSHM1,
+	-1,
+	NEO_INS_PUSH1,
+	NEO_INS_PUSH2,
+	NEO_INS_PUSH3,
+	NEO_INS_PUSH4,
+	NEO_INS_PUSH5,
+	NEO_INS_PUSH6,
+	NEO_INS_PUSH7,
+	NEO_INS_PUSH8,
+	NEO_INS_PUSH9,
+	NEO_INS_PUSH10,
+	NEO_INS_PUSH11,
+	NEO_INS_PUSH12,
+	NEO_INS_PUSH13,
+	NEO_INS_PUSH14,
+	NEO_INS_PUSH15,
+	NEO_INS_PUSH16,
+	NEO_INS_NOP,
+	NEO_INS_JMP,
+	NEO_INS_JMPIF,
+	NEO_INS_JMPIFNOT,
+	NEO_INS_CALL,
+	NEO_INS_RET,
+	NEO_INS_APPCALL,
+	NEO_INS_SYSCALL,
+	NEO_INS_TAILCALL,
+	NEO_INS_DUPFROMALTSTACK,
+	NEO_INS_TOALTSTACK,
+	NEO_INS_FROMALTSTACK,
+	NEO_INS_XDROP,
+	-1,
+	-1,
+	-1,
+	-1,
+	NEO_INS_XSWAP,
+	NEO_INS_XTUCK,
+	NEO_INS_DEPTH,
+	NEO_INS_DROP,
+	NEO_INS_DUP,
+	NEO_INS_NIP,
+	NEO_INS_OVER,
+	NEO_INS_PICK,
+	NEO_INS_ROLL,
+	NEO_INS_ROT,
+	NEO_INS_SWAP,
+	NEO_INS_TUCK,
+	NEO_INS_CAT,
+	NEO_INS_SUBSTR,
+	NEO_INS_LEFT,
+	NEO_INS_RIGHT,
+	NEO_INS_SIZE,
+	NEO_INS_INVERT,
+	NEO_INS_AND,
+	NEO_INS_OR,
+	NEO_INS_XOR,
+	NEO_INS_EQUAL,
+	NEO_INS_OP_EQUALVERIFY,
+	NEO_INS_OP_RESERVED1,
+	NEO_INS_OP_RESERVED2,
+	NEO_INS_INC,
+	NEO_INS_DEC,
+	NEO_INS_SIGN,
+	-1,
+	NEO_INS_NEGATE,
+	NEO_INS_ABS,
+	NEO_INS_NOT,
+	NEO_INS_NZ,
+	NEO_INS_ADD,
+	NEO_INS_SUB,
+	NEO_INS_MUL,
+	NEO_INS_DIV,
+	NEO_INS_MOD,
+	NEO_INS_SHL,
+	NEO_INS_SHR,
+	NEO_INS_BOOLAND,
+	NEO_INS_BOOLOR,
+	NEO_INS_NUMEQUAL,
+	-1,
+	NEO_INS_NUMNOTEQUAL,
+	NEO_INS_LT,
+	NEO_INS_GT,
+	NEO_INS_LTE,
+	NEO_INS_GTE,
+	NEO_INS_MIN,
+	NEO_INS_MAX,
+	NEO_INS_WITHIN,
+	-1,
+	NEO_INS_SHA1,
+	NEO_INS_SHA256,
+	NEO_INS_HASH160,
+	NEO_INS_HASH256,
+	-1,
+	NEO_INS_CHECKSIG,
+	NEO_INS_VERIFY,
+	NEO_INS_CHECKMULTISIG,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	NEO_INS_ARRAYSIZE,
+	NEO_INS_PACK,
+	NEO_INS_UNPACK,
+	NEO_INS_PICKITEM,
+	NEO_INS_SETITEM,
+	NEO_INS_NEWARRAY,
+	NEO_INS_NEWSTRUCT,
+	NEO_INS_NEWMAP,
+	NEO_INS_APPEND,
+	NEO_INS_REVERSE,
+	NEO_INS_REMOVE,
+	NEO_INS_HASKEY,
+	NEO_INS_KEYS,
+	NEO_INS_VALUES,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	NEO_INS_THROW,
+	NEO_INS_THROWIFNOT,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+};
+
+bool NEO_getInstruction(csh ud, const uint8_t *code, size_t code_len,
+	MCInst *MI, uint16_t *size, uint64_t address, void *inst_info)
+{
+	unsigned char opcode;
+
+	if (code_len == 0)
+		return false;
+
+	opcode = code[0];
+	if (opcodes[opcode] == -1) {
+		// invalid opcode
+		return false;
+	}
+
+	// valid opcode
+	MI->address = address;
+	MI->OpcodePub = MI->Opcode = opcode;
+
+	*size = neo_insn_opsize(opcode) + 1;
+	if (*size > 1) {
+		if (code_len < *size) {
+			// not enough data
+			return false;
+		}
+
+		// copy operand
+		memcpy(MI->neo_data, code + 1, *size - 1);
+	}
+
+	if (MI->flat_insn->detail) {
+		memset(&MI->flat_insn->detail->neo, 0, sizeof(cs_neo));
+		NEO_get_insn_id((cs_struct *)ud, MI->flat_insn, opcode);
+
+		MI->flat_insn->detail->regs_read_count = 0;
+		MI->flat_insn->detail->regs_write_count = 0;
+		MI->flat_insn->detail->groups_count = 0;
+
+		if (MI->flat_insn->detail->neo.pop) {
+			MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_STACK_READ;
+			MI->flat_insn->detail->groups_count++;
+		}
+
+		if (MI->flat_insn->detail->neo.push) {
+			MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_STACK_WRITE;
+			MI->flat_insn->detail->groups_count++;
+		}
+
+		// setup groups
+#if 0
+		switch(opcode) {
+			default:
+				break;
+			case NEO_INS_ADD:
+			case NEO_INS_MUL:
+				MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_MATH;
+				MI->flat_insn->detail->groups_count++;
+				break;
+
+			case NEO_INS_MSTORE:
+			case NEO_INS_MSTORE8:
+			case NEO_INS_CALLDATACOPY:
+			case NEO_INS_CODECOPY:
+			case NEO_INS_EXTCODECOPY:
+				MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_MEM_WRITE;
+				MI->flat_insn->detail->groups_count++;
+				break;
+
+		}
+#endif
+	}
+
+	return true;
+}
diff --git a/arch/NEO/NEODisassembler.h b/arch/NEO/NEODisassembler.h
new file mode 100644
index 0000000..a05a50e
--- /dev/null
+++ b/arch/NEO/NEODisassembler.h
@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifndef CS_NEODISASSEMBLER_H
+#define CS_NEODISASSEMBLER_H
+
+#include "../../MCInst.h"
+
+bool NEO_getInstruction(csh ud, const uint8_t *code, size_t code_len,
+		MCInst *instr, uint16_t *size, uint64_t address, void *info);
+
+#endif
diff --git a/arch/NEO/NEOInstPrinter.c b/arch/NEO/NEOInstPrinter.c
new file mode 100644
index 0000000..0b8283d
--- /dev/null
+++ b/arch/NEO/NEOInstPrinter.c
@@ -0,0 +1,25 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include "NEOInstPrinter.h"
+#include "NEOMapping.h"
+
+
+void NEO_printInst(MCInst *MI, struct SStream *O, void *PrinterInfo)
+{
+	int opsize;
+
+	// print mnemonic
+	SStream_concat(O, NEO_insn_name((csh)MI->csh, MI->Opcode));
+
+	opsize = neo_insn_opsize(MI->Opcode);
+	if (opsize) {
+		// print operand
+		unsigned int i;
+
+		SStream_concat0(O, "\t");
+		for (i = 0; i < opsize; i++) {
+			SStream_concat(O, "%02x", MI->neo_data[i]);
+		}
+	}
+}
diff --git a/arch/NEO/NEOInstPrinter.h b/arch/NEO/NEOInstPrinter.h
new file mode 100644
index 0000000..6034995
--- /dev/null
+++ b/arch/NEO/NEOInstPrinter.h
@@ -0,0 +1,17 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifndef CS_NEOINSTPRINTER_H
+#define CS_NEOINSTPRINTER_H
+
+
+#include "capstone/capstone.h"
+#include "../../MCInst.h"
+#include "../../SStream.h"
+#include "../../cs_priv.h"
+
+struct SStream;
+
+void NEO_printInst(MCInst *MI, struct SStream *O, void *Info);
+
+#endif
diff --git a/arch/NEO/NEOMapping.c b/arch/NEO/NEOMapping.c
new file mode 100644
index 0000000..21c46ba
--- /dev/null
+++ b/arch/NEO/NEOMapping.c
@@ -0,0 +1,339 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifdef CAPSTONE_HAS_NEO
+
+#include <string.h>
+
+#include "../../cs_priv.h"
+#include "../../utils.h"
+
+#include "NEOMapping.h"
+
+#ifndef CAPSTONE_DIET
+static cs_neo insns[256] = {
+#include "NEOMappingInsn.inc"
+};
+#endif
+
+// look for opsize of @id in @insns, given its size in @max.
+// return -1 if not found
+int neo_insn_opsize(unsigned int id)
+{
+	if (id >= 256)
+		return -1;
+
+	if (insns[id].fee == 255)
+		// unused opcode
+		return -1;
+
+	return insns[id].op_size;
+}
+
+// fill in details
+void NEO_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
+{
+	insn->id = id;
+#ifndef CAPSTONE_DIET
+	if (id < 256 && insns[id].fee != 255) {
+		if (h->detail) {
+			memcpy(&insn->detail->neo, &insns[id], sizeof(insns[id]));
+		}
+	}
+#endif
+}
+
+#ifndef CAPSTONE_DIET
+static name_map insn_name_maps[] = {
+	{ NEO_INS_PUSH0, "push0" },
+	{ NEO_INS_PUSHBYTES1, "pushbytes1" },
+	{ NEO_INS_PUSHBYTES2, "pushbytes2" },
+	{ NEO_INS_PUSHBYTES3, "pushbytes3" },
+	{ NEO_INS_PUSHBYTES4, "pushbytes4" },
+	{ NEO_INS_PUSHBYTES5, "pushbytes5" },
+	{ NEO_INS_PUSHBYTES6, "pushbytes6" },
+	{ NEO_INS_PUSHBYTES7, "pushbytes7" },
+	{ NEO_INS_PUSHBYTES8, "pushbytes8" },
+	{ NEO_INS_PUSHBYTES9, "pushbytes9" },
+	{ NEO_INS_PUSHBYTES10, "pushbytes10" },
+	{ NEO_INS_PUSHBYTES11, "pushbytes11" },
+	{ NEO_INS_PUSHBYTES12, "pushbytes12" },
+	{ NEO_INS_PUSHBYTES13, "pushbytes13" },
+	{ NEO_INS_PUSHBYTES14, "pushbytes14" },
+	{ NEO_INS_PUSHBYTES15, "pushbytes15" },
+	{ NEO_INS_PUSHBYTES16, "pushbytes16" },
+	{ NEO_INS_PUSHBYTES17, "pushbytes17" },
+	{ NEO_INS_PUSHBYTES18, "pushbytes18" },
+	{ NEO_INS_PUSHBYTES19, "pushbytes19" },
+	{ NEO_INS_PUSHBYTES20, "pushbytes20" },
+	{ NEO_INS_PUSHBYTES21, "pushbytes21" },
+	{ NEO_INS_PUSHBYTES22, "pushbytes22" },
+	{ NEO_INS_PUSHBYTES23, "pushbytes23" },
+	{ NEO_INS_PUSHBYTES24, "pushbytes24" },
+	{ NEO_INS_PUSHBYTES25, "pushbytes25" },
+	{ NEO_INS_PUSHBYTES26, "pushbytes26" },
+	{ NEO_INS_PUSHBYTES27, "pushbytes27" },
+	{ NEO_INS_PUSHBYTES28, "pushbytes28" },
+	{ NEO_INS_PUSHBYTES29, "pushbytes29" },
+	{ NEO_INS_PUSHBYTES30, "pushbytes30" },
+	{ NEO_INS_PUSHBYTES31, "pushbytes31" },
+	{ NEO_INS_PUSHBYTES32, "pushbytes32" },
+	{ NEO_INS_PUSHBYTES33, "pushbytes33" },
+	{ NEO_INS_PUSHBYTES34, "pushbytes34" },
+	{ NEO_INS_PUSHBYTES35, "pushbytes35" },
+	{ NEO_INS_PUSHBYTES36, "pushbytes36" },
+	{ NEO_INS_PUSHBYTES37, "pushbytes37" },
+	{ NEO_INS_PUSHBYTES38, "pushbytes38" },
+	{ NEO_INS_PUSHBYTES39, "pushbytes39" },
+	{ NEO_INS_PUSHBYTES40, "pushbytes40" },
+	{ NEO_INS_PUSHBYTES41, "pushbytes41" },
+	{ NEO_INS_PUSHBYTES42, "pushbytes42" },
+	{ NEO_INS_PUSHBYTES43, "pushbytes43" },
+	{ NEO_INS_PUSHBYTES44, "pushbytes44" },
+	{ NEO_INS_PUSHBYTES45, "pushbytes45" },
+	{ NEO_INS_PUSHBYTES46, "pushbytes46" },
+	{ NEO_INS_PUSHBYTES47, "pushbytes47" },
+	{ NEO_INS_PUSHBYTES48, "pushbytes48" },
+	{ NEO_INS_PUSHBYTES49, "pushbytes49" },
+	{ NEO_INS_PUSHBYTES50, "pushbytes50" },
+	{ NEO_INS_PUSHBYTES51, "pushbytes51" },
+	{ NEO_INS_PUSHBYTES52, "pushbytes52" },
+	{ NEO_INS_PUSHBYTES53, "pushbytes53" },
+	{ NEO_INS_PUSHBYTES54, "pushbytes54" },
+	{ NEO_INS_PUSHBYTES55, "pushbytes55" },
+	{ NEO_INS_PUSHBYTES56, "pushbytes56" },
+	{ NEO_INS_PUSHBYTES57, "pushbytes57" },
+	{ NEO_INS_PUSHBYTES58, "pushbytes58" },
+	{ NEO_INS_PUSHBYTES59, "pushbytes59" },
+	{ NEO_INS_PUSHBYTES60, "pushbytes60" },
+	{ NEO_INS_PUSHBYTES61, "pushbytes61" },
+	{ NEO_INS_PUSHBYTES62, "pushbytes62" },
+	{ NEO_INS_PUSHBYTES63, "pushbytes63" },
+	{ NEO_INS_PUSHBYTES64, "pushbytes64" },
+	{ NEO_INS_PUSHBYTES65, "pushbytes65" },
+	{ NEO_INS_PUSHBYTES66, "pushbytes66" },
+	{ NEO_INS_PUSHBYTES67, "pushbytes67" },
+	{ NEO_INS_PUSHBYTES68, "pushbytes68" },
+	{ NEO_INS_PUSHBYTES69, "pushbytes69" },
+	{ NEO_INS_PUSHBYTES70, "pushbytes70" },
+	{ NEO_INS_PUSHBYTES71, "pushbytes71" },
+	{ NEO_INS_PUSHBYTES72, "pushbytes72" },
+	{ NEO_INS_PUSHBYTES73, "pushbytes73" },
+	{ NEO_INS_PUSHBYTES74, "pushbytes74" },
+	{ NEO_INS_PUSHBYTES75, "pushbytes75" },
+	{ NEO_INS_PUSHDATA1, "pushdata1" },
+	{ NEO_INS_PUSHDATA2, "pushdata2" },
+	{ NEO_INS_PUSHDATA4, "pushdata4" },
+	{ NEO_INS_PUSHM1, "pushm1" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_PUSH1, "push1" },
+	{ NEO_INS_PUSH2, "push2" },
+	{ NEO_INS_PUSH3, "push3" },
+	{ NEO_INS_PUSH4, "push4" },
+	{ NEO_INS_PUSH5, "push5" },
+	{ NEO_INS_PUSH6, "push6" },
+	{ NEO_INS_PUSH7, "push7" },
+	{ NEO_INS_PUSH8, "push8" },
+	{ NEO_INS_PUSH9, "push9" },
+	{ NEO_INS_PUSH10, "push10" },
+	{ NEO_INS_PUSH11, "push11" },
+	{ NEO_INS_PUSH12, "push12" },
+	{ NEO_INS_PUSH13, "push13" },
+	{ NEO_INS_PUSH14, "push14" },
+	{ NEO_INS_PUSH15, "push15" },
+	{ NEO_INS_PUSH16, "push16" },
+	{ NEO_INS_NOP, "nop" },
+	{ NEO_INS_JMP, "jmp" },
+	{ NEO_INS_JMPIF, "jmpif" },
+	{ NEO_INS_JMPIFNOT, "jmpifnot" },
+	{ NEO_INS_CALL, "call" },
+	{ NEO_INS_RET, "ret" },
+	{ NEO_INS_APPCALL, "appcall" },
+	{ NEO_INS_SYSCALL, "syscall" },
+	{ NEO_INS_TAILCALL, "tailcall" },
+	{ NEO_INS_DUPFROMALTSTACK, "dupfromaltstack" },
+	{ NEO_INS_TOALTSTACK, "toaltstack" },
+	{ NEO_INS_FROMALTSTACK, "fromaltstack" },
+	{ NEO_INS_XDROP, "xdrop" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_XSWAP, "xswap" },
+	{ NEO_INS_XTUCK, "xtuck" },
+	{ NEO_INS_DEPTH, "depth" },
+	{ NEO_INS_DROP, "drop" },
+	{ NEO_INS_DUP, "dup" },
+	{ NEO_INS_NIP, "nip" },
+	{ NEO_INS_OVER, "over" },
+	{ NEO_INS_PICK, "pick" },
+	{ NEO_INS_ROLL, "roll" },
+	{ NEO_INS_ROT, "rot" },
+	{ NEO_INS_SWAP, "swap" },
+	{ NEO_INS_TUCK, "tuck" },
+	{ NEO_INS_CAT, "cat" },
+	{ NEO_INS_SUBSTR, "substr" },
+	{ NEO_INS_LEFT, "left" },
+	{ NEO_INS_RIGHT, "right" },
+	{ NEO_INS_SIZE, "size" },
+	{ NEO_INS_INVERT, "invert" },
+	{ NEO_INS_AND, "and" },
+	{ NEO_INS_OR, "or" },
+	{ NEO_INS_XOR, "xor" },
+	{ NEO_INS_EQUAL, "equal" },
+	{ NEO_INS_OP_EQUALVERIFY, "op_equalverify" },
+	{ NEO_INS_OP_RESERVED1, "op_reserved1" },
+	{ NEO_INS_OP_RESERVED2, "op_reserved2" },
+	{ NEO_INS_INC, "inc" },
+	{ NEO_INS_DEC, "dec" },
+	{ NEO_INS_SIGN, "sign" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_NEGATE, "negate" },
+	{ NEO_INS_ABS, "abs" },
+	{ NEO_INS_NOT, "not" },
+	{ NEO_INS_NZ, "nz" },
+	{ NEO_INS_ADD, "add" },
+	{ NEO_INS_SUB, "sub" },
+	{ NEO_INS_MUL, "mul" },
+	{ NEO_INS_DIV, "div" },
+	{ NEO_INS_MOD, "mod" },
+	{ NEO_INS_SHL, "shl" },
+	{ NEO_INS_SHR, "shr" },
+	{ NEO_INS_BOOLAND, "booland" },
+	{ NEO_INS_BOOLOR, "boolor" },
+	{ NEO_INS_NUMEQUAL, "numequal" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_NUMNOTEQUAL, "numnotequal" },
+	{ NEO_INS_LT, "lt" },
+	{ NEO_INS_GT, "gt" },
+	{ NEO_INS_LTE, "lte" },
+	{ NEO_INS_GTE, "gte" },
+	{ NEO_INS_MIN, "min" },
+	{ NEO_INS_MAX, "max" },
+	{ NEO_INS_WITHIN, "within" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_SHA1, "sha1" },
+	{ NEO_INS_SHA256, "sha256" },
+	{ NEO_INS_HASH160, "hash160" },
+	{ NEO_INS_HASH256, "hash256" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_CHECKSIG, "checksig" },
+	{ NEO_INS_VERIFY, "verify" },
+	{ NEO_INS_CHECKMULTISIG, "checkmultisig" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_ARRAYSIZE, "arraysize" },
+	{ NEO_INS_PACK, "pack" },
+	{ NEO_INS_UNPACK, "unpack" },
+	{ NEO_INS_PICKITEM, "pickitem" },
+	{ NEO_INS_SETITEM, "setitem" },
+	{ NEO_INS_NEWARRAY, "newarray" },
+	{ NEO_INS_NEWSTRUCT, "newstruct" },
+	{ NEO_INS_NEWMAP, "newmap" },
+	{ NEO_INS_APPEND, "append" },
+	{ NEO_INS_REVERSE, "reverse" },
+	{ NEO_INS_REMOVE, "remove" },
+	{ NEO_INS_HASKEY, "haskey" },
+	{ NEO_INS_KEYS, "keys" },
+	{ NEO_INS_VALUES, "values" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_THROW, "throw" },
+	{ NEO_INS_THROWIFNOT, "throwifnot" },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+	{ NEO_INS_INVALID, NULL },
+};
+#endif
+
+const char *NEO_insn_name(csh handle, unsigned int id)
+{
+#ifndef CAPSTONE_DIET
+	if (id >= ARR_SIZE(insn_name_maps))
+		return NULL;
+	else
+		return insn_name_maps[id].name;
+#else
+	return NULL;
+#endif
+}
+
+#ifndef CAPSTONE_DIET
+static name_map group_name_maps[] = {
+	// generic groups
+	{ NEO_GRP_INVALID, NULL },
+	{ NEO_GRP_JUMP,	"jump" },
+	// special groups
+	{ NEO_GRP_MATH,	"math" },
+	{ NEO_GRP_STACK_WRITE, "stack_write" },
+	{ NEO_GRP_STACK_READ, "stack_read" },
+};
+#endif
+
+const char *NEO_group_name(csh handle, unsigned int id)
+{
+#ifndef CAPSTONE_DIET
+	return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);
+#else
+	return NULL;
+#endif
+}
+#endif
diff --git a/arch/NEO/NEOMapping.h b/arch/NEO/NEOMapping.h
new file mode 100644
index 0000000..8d780f2
--- /dev/null
+++ b/arch/NEO/NEOMapping.h
@@ -0,0 +1,9 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include <capstone/capstone.h>
+
+void NEO_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
+const char *NEO_insn_name(csh handle, unsigned int id);
+const char *NEO_group_name(csh handle, unsigned int id);
+int neo_insn_opsize(unsigned int id);
diff --git a/arch/NEO/NEOMappingInsn.inc b/arch/NEO/NEOMappingInsn.inc
new file mode 100644
index 0000000..80398b3
--- /dev/null
+++ b/arch/NEO/NEOMappingInsn.inc
@@ -0,0 +1,259 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+{ 0, 0, 1, NEO_FEE_0 },
+{ 1, 0, 1, NEO_FEE_0 },
+{ 2, 0, 2, NEO_FEE_0 },
+{ 3, 0, 3, NEO_FEE_0 },
+{ 4, 0, 4, NEO_FEE_0 },
+{ 5, 0, 5, NEO_FEE_0 },
+{ 6, 0, 6, NEO_FEE_0 },
+{ 7, 0, 7, NEO_FEE_0 },
+{ 8, 0, 8, NEO_FEE_0 },
+{ 9, 0, 9, NEO_FEE_0 },
+{ 10, 0, 10, NEO_FEE_0 },
+{ 11, 0, 11, NEO_FEE_0 },
+{ 12, 0, 12, NEO_FEE_0 },
+{ 13, 0, 13, NEO_FEE_0 },
+{ 14, 0, 14, NEO_FEE_0 },
+{ 15, 0, 15, NEO_FEE_0 },
+{ 16, 0, 16, NEO_FEE_0 },
+{ 17, 0, 17, NEO_FEE_0 },
+{ 18, 0, 18, NEO_FEE_0 },
+{ 19, 0, 19, NEO_FEE_0 },
+{ 20, 0, 20, NEO_FEE_0 },
+{ 21, 0, 21, NEO_FEE_0 },
+{ 22, 0, 22, NEO_FEE_0 },
+{ 23, 0, 23, NEO_FEE_0 },
+{ 24, 0, 24, NEO_FEE_0 },
+{ 25, 0, 25, NEO_FEE_0 },
+{ 26, 0, 26, NEO_FEE_0 },
+{ 27, 0, 27, NEO_FEE_0 },
+{ 28, 0, 28, NEO_FEE_0 },
+{ 29, 0, 29, NEO_FEE_0 },
+{ 30, 0, 30, NEO_FEE_0 },
+{ 31, 0, 31, NEO_FEE_0 },
+{ 32, 0, 32, NEO_FEE_0 },
+{ 33, 0, 33, NEO_FEE_0 },
+{ 34, 0, 34, NEO_FEE_0 },
+{ 35, 0, 35, NEO_FEE_0 },
+{ 36, 0, 36, NEO_FEE_0 },
+{ 37, 0, 37, NEO_FEE_0 },
+{ 38, 0, 38, NEO_FEE_0 },
+{ 39, 0, 39, NEO_FEE_0 },
+{ 40, 0, 40, NEO_FEE_0 },
+{ 41, 0, 41, NEO_FEE_0 },
+{ 42, 0, 42, NEO_FEE_0 },
+{ 43, 0, 43, NEO_FEE_0 },
+{ 44, 0, 44, NEO_FEE_0 },
+{ 45, 0, 45, NEO_FEE_0 },
+{ 46, 0, 46, NEO_FEE_0 },
+{ 47, 0, 47, NEO_FEE_0 },
+{ 48, 0, 48, NEO_FEE_0 },
+{ 49, 0, 49, NEO_FEE_0 },
+{ 50, 0, 50, NEO_FEE_0 },
+{ 51, 0, 51, NEO_FEE_0 },
+{ 52, 0, 52, NEO_FEE_0 },
+{ 53, 0, 53, NEO_FEE_0 },
+{ 54, 0, 54, NEO_FEE_0 },
+{ 55, 0, 55, NEO_FEE_0 },
+{ 56, 0, 56, NEO_FEE_0 },
+{ 57, 0, 57, NEO_FEE_0 },
+{ 58, 0, 58, NEO_FEE_0 },
+{ 59, 0, 59, NEO_FEE_0 },
+{ 60, 0, 60, NEO_FEE_0 },
+{ 61, 0, 61, NEO_FEE_0 },
+{ 62, 0, 62, NEO_FEE_0 },
+{ 63, 0, 63, NEO_FEE_0 },
+{ 64, 0, 64, NEO_FEE_0 },
+{ 65, 0, 65, NEO_FEE_0 },
+{ 66, 0, 66, NEO_FEE_0 },
+{ 67, 0, 67, NEO_FEE_0 },
+{ 68, 0, 68, NEO_FEE_0 },
+{ 69, 0, 69, NEO_FEE_0 },
+{ 70, 0, 70, NEO_FEE_0 },
+{ 71, 0, 71, NEO_FEE_0 },
+{ 72, 0, 72, NEO_FEE_0 },
+{ 73, 0, 73, NEO_FEE_0 },
+{ 74, 0, 74, NEO_FEE_0 },
+{ 75, 0, 75, NEO_FEE_0 },
+{ 1, 0, 1, NEO_FEE_0 },
+{ 2, 0, 2, NEO_FEE_0 },
+{ 4, 0, 4, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 0, NEO_FEE_0 },
+{ 2, 0, 0, NEO_FEE_0001 },
+{ 2, 1, 0, NEO_FEE_0001 },
+{ 2, 1, 0, NEO_FEE_0001 },
+{ 2, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 32, 0, 0, NEO_FEE_001 },
+{ 1, 0, 0, NEO_FEE_0001 },
+{ 32, 0, 0, NEO_FEE_001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 1, 2, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 3, 3, NEO_FEE_0001 },
+{ 0, 2, 2, NEO_FEE_0001 },
+{ 0, 2, 3, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 3, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_001 },
+{ 0, 0, 0, NEO_FEE_001 },
+{ 0, 0, 0, NEO_FEE_002 },
+{ 0, 0, 0, NEO_FEE_002 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
diff --git a/arch/NEO/NEOModule.c b/arch/NEO/NEOModule.c
new file mode 100644
index 0000000..95a2009
--- /dev/null
+++ b/arch/NEO/NEOModule.c
@@ -0,0 +1,33 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifdef CAPSTONE_HAS_NEO
+
+#include "../../cs_priv.h"
+#include "NEODisassembler.h"
+#include "NEOInstPrinter.h"
+#include "NEOMapping.h"
+#include "NEOModule.h"
+
+cs_err NEO_global_init(cs_struct *ud)
+{
+	// verify if requested mode is valid
+	if (ud->mode)
+		return CS_ERR_MODE;
+
+	ud->printer = NEO_printInst;
+	ud->printer_info = NULL;
+	ud->insn_id = NEO_get_insn_id;
+	ud->insn_name = NEO_insn_name;
+	ud->group_name = NEO_group_name;
+	ud->disasm = NEO_getInstruction;
+
+	return CS_ERR_OK;
+}
+
+cs_err NEO_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+	return CS_ERR_OK;
+}
+
+#endif
diff --git a/arch/NEO/NEOModule.h b/arch/NEO/NEOModule.h
new file mode 100644
index 0000000..f552f50
--- /dev/null
+++ b/arch/NEO/NEOModule.h
@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Travis Finkenauer <tmfinken@gmail.com>, 2018 */
+
+#ifndef CS_NEO_MODULE_H
+#define CS_NEO_MODULE_H
+
+#include "../../utils.h"
+
+cs_err NEO_global_init(cs_struct *ud);
+cs_err NEO_option(cs_struct *handle, cs_opt_type type, size_t value);
+
+#endif
diff --git a/config.mk b/config.mk
index 3b078a7..12bb00e 100644
--- a/config.mk
+++ b/config.mk
@@ -4,7 +4,7 @@
 ################################################################################
 # Specify which archs you want to compile in. By default, we build all archs.
 
-CAPSTONE_ARCHS ?= arm aarch64 m68k mips powerpc sparc systemz x86 xcore tms320c64x m680x evm
+CAPSTONE_ARCHS ?= arm aarch64 m68k mips powerpc sparc systemz x86 xcore tms320c64x m680x evm neo
 
 
 ################################################################################
diff --git a/cs.c b/cs.c
index d2ffecc..4f20d13 100644
--- a/cs.c
+++ b/cs.c
@@ -58,6 +58,7 @@
 #include "arch/M680X/M680XModule.h"
 #include "arch/M68K/M68KModule.h"
 #include "arch/Mips/MipsModule.h"
+#include "arch/NEO/NEOModule.h"
 #include "arch/PowerPC/PPCModule.h"
 #include "arch/Sparc/SparcModule.h"
 #include "arch/SystemZ/SystemZModule.h"
@@ -127,6 +128,11 @@
 #else
 	NULL,
 #endif
+#ifdef CAPSTONE_HAS_NEO
+	NEO_global_init,
+#else
+	NULL,
+#endif
 };
 
 // support cs_option() for all archs
@@ -191,6 +197,11 @@
 #else
 	NULL,
 #endif
+#ifdef CAPSTONE_HAS_NEO
+	NEO_option,
+#else
+	NULL,
+#endif
 };
 
 // bitmask for finding disallowed modes for an arch:
@@ -263,6 +274,11 @@
 #else
 	0,
 #endif
+#ifdef CAPSTONE_HAS_NEO
+	0,
+#else
+	0,
+#endif
 };
 
 // bitmask of enabled architectures
@@ -303,6 +319,9 @@
 #ifdef CAPSTONE_HAS_EVM
 	| (1 << CS_ARCH_EVM)
 #endif
+#ifdef CAPSTONE_HAS_NEO
+	| (1 << CS_ARCH_NEO)
+#endif
 ;
 
 
@@ -375,7 +394,8 @@
 				(1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) |
 				(1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE) |
 				(1 << CS_ARCH_M68K) | (1 << CS_ARCH_TMS320C64X) |
-				(1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM));
+				(1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM) |
+				(1 << CS_ARCH_NEO));
 
 	if ((unsigned int)query < CS_ARCH_MAX)
 		return all_arch & (1 << query);
@@ -641,6 +661,9 @@
 		case CS_ARCH_EVM:
 			// EVM alignment is 1.
 			return 1;
+		case CS_ARCH_NEO:
+			// NEO alignment is 1.
+			return 1;
 	}
 }
 
@@ -1359,6 +1382,13 @@
 					count++;
 #endif
 			break;
+		case CS_ARCH_NEO:
+#if 0
+			for (i = 0; i < insn->detail->neo.op_count; i++)
+				if (insn->detail->neo.operands[i].type == (neo_op_type)op_type)
+					count++;
+#endif
+			break;
 	}
 
 	return count;
@@ -1494,6 +1524,16 @@
 			}
 #endif
 			break;
+		case CS_ARCH_NEO:
+#if 0
+			for (i = 0; i < insn->detail->neo.op_count; i++) {
+				if (insn->detail->neo.operands[i].type == (neo_op_type)op_type)
+					count++;
+				if (count == post)
+					return i;
+			}
+#endif
+			break;
 	}
 
 	return -1;
diff --git a/cstool/cstool.c b/cstool/cstool.c
index cd3483e..835e3fe 100644
--- a/cstool/cstool.c
+++ b/cstool/cstool.c
@@ -56,6 +56,7 @@
 	{ "hd6309", CS_ARCH_M680X, CS_MODE_M680X_6309 },
 	{ "hcs08", CS_ARCH_M680X, CS_MODE_M680X_HCS08 },
 	{ "evm", CS_ARCH_EVM, 0 },
+	{ "neo", CS_ARCH_NEO, 0 },
 	{ NULL }
 };
 
@@ -71,6 +72,7 @@
 void print_insn_detail_tms320c64x(csh handle, cs_insn *ins);
 void print_insn_detail_m680x(csh handle, cs_insn *ins);
 void print_insn_detail_evm(csh handle, cs_insn *ins);
+void print_insn_detail_neo(csh handle, cs_insn *ins);
 
 static void print_details(csh handle, cs_arch arch, cs_mode md, cs_insn *ins);
 
@@ -208,6 +210,10 @@
 		printf("        evm:       Ethereum Virtual Machine\n");
 	}
 
+	if (cs_support(CS_ARCH_NEO)) {
+		printf("        neo:       NEO Virtual Machine\n");
+	}
+
 	printf("\nExtra options:\n");
 	printf("        -d show detailed information of the instructions\n");
 	printf("        -u show immediates as unsigned\n\n");
@@ -252,6 +258,9 @@
 		case CS_ARCH_EVM:
 			print_insn_detail_evm(handle, ins);
 			break;
+		case CS_ARCH_NEO:
+			print_insn_detail_neo(handle, ins);
+			break;
 		default: break;
 	}
 
diff --git a/cstool/cstool_neo.c b/cstool/cstool_neo.c
new file mode 100644
index 0000000..9943fea
--- /dev/null
+++ b/cstool/cstool_neo.c
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <capstone/capstone.h>
+
+void print_string_hex(char *comment, unsigned char *str, size_t len);
+
+void print_insn_detail_neo(csh handle, cs_insn *ins)
+{
+	cs_neo *neo;
+	int i;
+
+	// detail can be NULL on "data" instruction if SKIPDATA option is turned ON
+	if (ins->detail == NULL)
+		return;
+
+	neo = &(ins->detail->neo);
+
+	if (neo->pop)
+		printf("\tPop:     %u\n", neo->pop);
+
+	if (neo->push)
+		printf("\tPush:    %u\n", neo->push);
+
+	if (neo->fee) {
+		switch(neo->fee) {
+			default:
+				break;
+			case NEO_FEE_0:
+				printf("\tGas fee: 0\n");
+				break;
+			case NEO_FEE_01:
+				printf("\tGas fee: 0.1\n");
+				break;
+			case NEO_FEE_001:
+				printf("\tGas fee: 0.01\n");
+				break;
+			case NEO_FEE_002:
+				printf("\tGas fee: 0.02\n");
+				break;
+			case NEO_FEE_0001:
+				printf("\tGas fee: 0.001\n");
+				break;
+		}
+	}
+}
diff --git a/include/capstone/capstone.h b/include/capstone/capstone.h
index 39b18c9..2ebb093 100644
--- a/include/capstone/capstone.h
+++ b/include/capstone/capstone.h
@@ -84,6 +84,7 @@
 	CS_ARCH_TMS320C64X,	// TMS320C64x architecture
 	CS_ARCH_M680X,		// 680X architecture
 	CS_ARCH_EVM,		// Ethereum architecture
+	CS_ARCH_NEO,		// Ethereum architecture
 	CS_ARCH_MAX,
 	CS_ARCH_ALL = 0xFFFF, // All architectures - for cs_support()
 } cs_arch;
@@ -257,6 +258,7 @@
 	// X86:     1 bytes.
 	// XCore:   2 bytes.
 	// EVM:     1 bytes.
+	// NEO:     1 bytes.
 	cs_skipdata_cb_t callback; 	// default value is NULL
 
 	// User-defined data to be passed to @callback function pointer.
@@ -276,6 +278,7 @@
 #include "tms320c64x.h"
 #include "m680x.h"
 #include "evm.h"
+#include "neo.h"
 
 // NOTE: All information in cs_detail is only available when CS_OPT_DETAIL = CS_OPT_ON
 typedef struct cs_detail {
@@ -302,6 +305,7 @@
 		cs_tms320c64x tms320c64x;  // TMS320C64x architecture
 		cs_m680x m680x; // M680X architecture
 		cs_evm evm;	    // Ethereum architecture
+		cs_neo neo;	    // NEO architecture
 	};
 } cs_detail;
 
diff --git a/include/capstone/neo.h b/include/capstone/neo.h
new file mode 100644
index 0000000..95843e5
--- /dev/null
+++ b/include/capstone/neo.h
@@ -0,0 +1,239 @@
+#ifndef CAPSTONE_NEO_H
+#define CAPSTONE_NEO_H
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2018 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "platform.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable:4201)
+#endif
+
+typedef enum neo_fee {
+	NEO_FEE_0,      // fee 0
+	NEO_FEE_01,     // fee 0.1
+	NEO_FEE_001,    // fee 0.01
+	NEO_FEE_002,    // fee 0.02
+	NEO_FEE_0001,   // fee 0.001
+} neo_fee;
+
+// Instruction structure
+typedef struct cs_neo {
+    unsigned char op_size; // operand size
+    unsigned char pop;     // number of items popped from the stack
+    unsigned char push;    // number of items pushed into the stack
+    neo_fee fee;           // gas fee for the instruction
+} cs_neo;
+
+//> NEO instruction
+typedef enum cs_neo_insn {
+	NEO_INS_PUSH0 = 0,
+	NEO_INS_PUSHBYTES1 = 1,
+	NEO_INS_PUSHBYTES2 = 2,
+	NEO_INS_PUSHBYTES3 = 3,
+	NEO_INS_PUSHBYTES4 = 4,
+	NEO_INS_PUSHBYTES5 = 5,
+	NEO_INS_PUSHBYTES6 = 6,
+	NEO_INS_PUSHBYTES7 = 7,
+	NEO_INS_PUSHBYTES8 = 8,
+	NEO_INS_PUSHBYTES9 = 9,
+	NEO_INS_PUSHBYTES10 = 10,
+	NEO_INS_PUSHBYTES11 = 11,
+	NEO_INS_PUSHBYTES12 = 12,
+	NEO_INS_PUSHBYTES13 = 13,
+	NEO_INS_PUSHBYTES14 = 14,
+	NEO_INS_PUSHBYTES15 = 15,
+	NEO_INS_PUSHBYTES16 = 16,
+	NEO_INS_PUSHBYTES17 = 17,
+	NEO_INS_PUSHBYTES18 = 18,
+	NEO_INS_PUSHBYTES19 = 19,
+	NEO_INS_PUSHBYTES20 = 20,
+	NEO_INS_PUSHBYTES21 = 21,
+	NEO_INS_PUSHBYTES22 = 22,
+	NEO_INS_PUSHBYTES23 = 23,
+	NEO_INS_PUSHBYTES24 = 24,
+	NEO_INS_PUSHBYTES25 = 25,
+	NEO_INS_PUSHBYTES26 = 26,
+	NEO_INS_PUSHBYTES27 = 27,
+	NEO_INS_PUSHBYTES28 = 28,
+	NEO_INS_PUSHBYTES29 = 29,
+	NEO_INS_PUSHBYTES30 = 30,
+	NEO_INS_PUSHBYTES31 = 31,
+	NEO_INS_PUSHBYTES32 = 32,
+	NEO_INS_PUSHBYTES33 = 33,
+	NEO_INS_PUSHBYTES34 = 34,
+	NEO_INS_PUSHBYTES35 = 35,
+	NEO_INS_PUSHBYTES36 = 36,
+	NEO_INS_PUSHBYTES37 = 37,
+	NEO_INS_PUSHBYTES38 = 38,
+	NEO_INS_PUSHBYTES39 = 39,
+	NEO_INS_PUSHBYTES40 = 40,
+	NEO_INS_PUSHBYTES41 = 41,
+	NEO_INS_PUSHBYTES42 = 42,
+	NEO_INS_PUSHBYTES43 = 43,
+	NEO_INS_PUSHBYTES44 = 44,
+	NEO_INS_PUSHBYTES45 = 45,
+	NEO_INS_PUSHBYTES46 = 46,
+	NEO_INS_PUSHBYTES47 = 47,
+	NEO_INS_PUSHBYTES48 = 48,
+	NEO_INS_PUSHBYTES49 = 49,
+	NEO_INS_PUSHBYTES50 = 50,
+	NEO_INS_PUSHBYTES51 = 51,
+	NEO_INS_PUSHBYTES52 = 52,
+	NEO_INS_PUSHBYTES53 = 53,
+	NEO_INS_PUSHBYTES54 = 54,
+	NEO_INS_PUSHBYTES55 = 55,
+	NEO_INS_PUSHBYTES56 = 56,
+	NEO_INS_PUSHBYTES57 = 57,
+	NEO_INS_PUSHBYTES58 = 58,
+	NEO_INS_PUSHBYTES59 = 59,
+	NEO_INS_PUSHBYTES60 = 60,
+	NEO_INS_PUSHBYTES61 = 61,
+	NEO_INS_PUSHBYTES62 = 62,
+	NEO_INS_PUSHBYTES63 = 63,
+	NEO_INS_PUSHBYTES64 = 64,
+	NEO_INS_PUSHBYTES65 = 65,
+	NEO_INS_PUSHBYTES66 = 66,
+	NEO_INS_PUSHBYTES67 = 67,
+	NEO_INS_PUSHBYTES68 = 68,
+	NEO_INS_PUSHBYTES69 = 69,
+	NEO_INS_PUSHBYTES70 = 70,
+	NEO_INS_PUSHBYTES71 = 71,
+	NEO_INS_PUSHBYTES72 = 72,
+	NEO_INS_PUSHBYTES73 = 73,
+	NEO_INS_PUSHBYTES74 = 74,
+	NEO_INS_PUSHBYTES75 = 75,
+	NEO_INS_PUSHDATA1 = 76,
+	NEO_INS_PUSHDATA2 = 77,
+	NEO_INS_PUSHDATA4 = 78,
+	NEO_INS_PUSHM1 = 79,
+	NEO_INS_PUSH1 = 81,
+	NEO_INS_PUSH2 = 82,
+	NEO_INS_PUSH3 = 83,
+	NEO_INS_PUSH4 = 84,
+	NEO_INS_PUSH5 = 85,
+	NEO_INS_PUSH6 = 86,
+	NEO_INS_PUSH7 = 87,
+	NEO_INS_PUSH8 = 88,
+	NEO_INS_PUSH9 = 89,
+	NEO_INS_PUSH10 = 90,
+	NEO_INS_PUSH11 = 91,
+	NEO_INS_PUSH12 = 92,
+	NEO_INS_PUSH13 = 93,
+	NEO_INS_PUSH14 = 94,
+	NEO_INS_PUSH15 = 95,
+	NEO_INS_PUSH16 = 96,
+	NEO_INS_NOP = 97,
+	NEO_INS_JMP = 98,
+	NEO_INS_JMPIF = 99,
+	NEO_INS_JMPIFNOT = 100,
+	NEO_INS_CALL = 101,
+	NEO_INS_RET = 102,
+	NEO_INS_APPCALL = 103,
+	NEO_INS_SYSCALL = 104,
+	NEO_INS_TAILCALL = 105,
+	NEO_INS_DUPFROMALTSTACK = 106,
+	NEO_INS_TOALTSTACK = 107,
+	NEO_INS_FROMALTSTACK = 108,
+	NEO_INS_XDROP = 109,
+	NEO_INS_XSWAP = 114,
+	NEO_INS_XTUCK = 115,
+	NEO_INS_DEPTH = 116,
+	NEO_INS_DROP = 117,
+	NEO_INS_DUP = 118,
+	NEO_INS_NIP = 119,
+	NEO_INS_OVER = 120,
+	NEO_INS_PICK = 121,
+	NEO_INS_ROLL = 122,
+	NEO_INS_ROT = 123,
+	NEO_INS_SWAP = 124,
+	NEO_INS_TUCK = 125,
+	NEO_INS_CAT = 126,
+	NEO_INS_SUBSTR = 127,
+	NEO_INS_LEFT = 128,
+	NEO_INS_RIGHT = 129,
+	NEO_INS_SIZE = 130,
+	NEO_INS_INVERT = 131,
+	NEO_INS_AND = 132,
+	NEO_INS_OR = 133,
+	NEO_INS_XOR = 134,
+	NEO_INS_EQUAL = 135,
+	NEO_INS_OP_EQUALVERIFY = 136,
+	NEO_INS_OP_RESERVED1 = 137,
+	NEO_INS_OP_RESERVED2 = 138,
+	NEO_INS_INC = 139,
+	NEO_INS_DEC = 140,
+	NEO_INS_SIGN = 141,
+	NEO_INS_NEGATE = 143,
+	NEO_INS_ABS = 144,
+	NEO_INS_NOT = 145,
+	NEO_INS_NZ = 146,
+	NEO_INS_ADD = 147,
+	NEO_INS_SUB = 148,
+	NEO_INS_MUL = 149,
+	NEO_INS_DIV = 150,
+	NEO_INS_MOD = 151,
+	NEO_INS_SHL = 152,
+	NEO_INS_SHR = 153,
+	NEO_INS_BOOLAND = 154,
+	NEO_INS_BOOLOR = 155,
+	NEO_INS_NUMEQUAL = 156,
+	NEO_INS_NUMNOTEQUAL = 158,
+	NEO_INS_LT = 159,
+	NEO_INS_GT = 160,
+	NEO_INS_LTE = 161,
+	NEO_INS_GTE = 162,
+	NEO_INS_MIN = 163,
+	NEO_INS_MAX = 164,
+	NEO_INS_WITHIN = 165,
+	NEO_INS_SHA1 = 167,
+	NEO_INS_SHA256 = 168,
+	NEO_INS_HASH160 = 169,
+	NEO_INS_HASH256 = 170,
+	NEO_INS_CHECKSIG = 172,
+	NEO_INS_VERIFY = 173,
+	NEO_INS_CHECKMULTISIG = 174,
+	NEO_INS_ARRAYSIZE = 192,
+	NEO_INS_PACK = 193,
+	NEO_INS_UNPACK = 194,
+	NEO_INS_PICKITEM = 195,
+	NEO_INS_SETITEM = 196,
+	NEO_INS_NEWARRAY = 197,
+	NEO_INS_NEWSTRUCT = 198,
+	NEO_INS_NEWMAP = 199,
+	NEO_INS_APPEND = 200,
+	NEO_INS_REVERSE = 201,
+	NEO_INS_REMOVE = 202,
+	NEO_INS_HASKEY = 203,
+	NEO_INS_KEYS = 204,
+	NEO_INS_VALUES = 205,
+	NEO_INS_THROW = 240,
+	NEO_INS_THROWIFNOT = 241,
+
+	NEO_INS_INVALID = 512,
+	NEO_INS_ENDING,   // <-- mark the end of the list of instructions
+} cs_neo_insn;
+
+//> Group of NEO instructions
+typedef enum cs_neo_insn_group {
+	NEO_GRP_INVALID = 0, // = CS_GRP_INVALID
+
+	NEO_GRP_JUMP,          // all jump instructions
+
+	NEO_GRP_MATH = 8,      // math instructions
+	NEO_GRP_STACK_WRITE,
+	NEO_GRP_STACK_READ,
+
+	NEO_GRP_ENDING,   // <-- mark the end of the list of groups
+} cs_neo_insn_group;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif