code

var InstructionAuxStackPops = map[Opcode][]byte{
	ADD:    {},
	MUL:    {},
	SUB:    {},
	DIV:    {},
	SDIV:   {},
	MOD:    {},
	SMOD:   {},
	ADDMOD: {},
	MULMOD: {},
	EXP:    {},

	LT:         {},
	GT:         {},
	SLT:        {},
	SGT:        {},
	EQ:         {},
	ISZERO:     {},
	AND:        {},
	OR:         {},
	XOR:        {},
	NOT:        {},
	BYTE:       {},
	SIGNEXTEND: {},

	SHA3: {},
	TYPE: {},

	POP:   {},
	SPUSH: {},
	RPUSH: {},
	RSET:  {},

	JUMP:          {},
	CJUMP:         {},
	STACKEMPTY:    {},
	PCPUSH:        {},
	AUXPUSH:       {},
	AUXPOP:        {0},
	AUXSTACKEMPTY: {},
	NOP:           {},
	ERRPUSH:       {},
	ERRSET:        {},

	DUP0:  {},
	DUP1:  {},
	DUP2:  {},
	SWAP1: {},
	SWAP2: {},

	TGET: {},
	TSET: {},
	TLEN: {},

	BREAKPOINT: {},
	LOG:        {},

	SEND:    {},
	NBSEND:  {},
	GETTIME: {},
	INBOX:   {},
	ERROR:   {},
	HALT:    {},
	DEBUG:   {},
}

var InstructionNames = map[Opcode]string{
	ADD:    "add",
	MUL:    "mul",
	SUB:    "sub",
	DIV:    "div",
	SDIV:   "sdiv",
	MOD:    "mod",
	SMOD:   "smod",
	ADDMOD: "addmod",
	MULMOD: "mulmod",
	EXP:    "exp",

	LT:         "lt",
	GT:         "gt",
	SLT:        "slt",
	SGT:        "sgt",
	EQ:         "eq",
	ISZERO:     "iszero",
	AND:        "and",
	OR:         "or",
	XOR:        "xor",
	NOT:        "not",
	BYTE:       "byte",
	SIGNEXTEND: "signextend",

	SHA3: "hash",
	TYPE: "type",

	POP:           "pop",
	SPUSH:         "spush",
	RPUSH:         "rpush",
	RSET:          "rset",
	JUMP:          "jump",
	CJUMP:         "cjump",
	STACKEMPTY:    "stackempty",
	PCPUSH:        "pcpush",
	AUXPUSH:       "auxpush",
	AUXPOP:        "auxpop",
	AUXSTACKEMPTY: "auxstackempty",
	NOP:           "nop",
	ERRPUSH:       "errpush",
	ERRSET:        "errset",

	DUP0:  "dup0",
	DUP1:  "dup1",
	DUP2:  "dup2",
	SWAP1: "swap1",
	SWAP2: "swap2",

	TGET: "tget",
	TSET: "tset",
	TLEN: "tlen",

	BREAKPOINT: "breakpoint",
	LOG:        "log",

	SEND:    "send",
	NBSEND:  "nbsend",
	GETTIME: "gettime",
	INBOX:   "inbox",
	ERROR:   "error",
	HALT:    "halt",
	DEBUG:   "debug",
}

var InstructionStackPops = map[Opcode][]byte{
	ADD:    {1, 1},
	MUL:    {1, 1},
	SUB:    {1, 1},
	DIV:    {1, 1},
	SDIV:   {1, 1},
	MOD:    {1, 1},
	SMOD:   {1, 1},
	ADDMOD: {1, 1, 1},
	MULMOD: {1, 1, 1},
	EXP:    {1, 1},

	LT:         {1, 1},
	GT:         {1, 1},
	SLT:        {1, 1},
	SGT:        {1, 1},
	EQ:         {0, 0},
	ISZERO:     {1},
	AND:        {1, 1},
	OR:         {1, 1},
	XOR:        {1, 1},
	NOT:        {1},
	BYTE:       {1, 1},
	SIGNEXTEND: {1, 1},

	SHA3: {0},
	TYPE: {1},

	POP:   {0},
	SPUSH: {},
	RPUSH: {},
	RSET:  {0},

	JUMP:          {0},
	CJUMP:         {0, 1},
	STACKEMPTY:    {},
	PCPUSH:        {},
	AUXPUSH:       {0},
	AUXPOP:        {},
	AUXSTACKEMPTY: {},
	NOP:           {},
	ERRPUSH:       {},
	ERRSET:        {1},

	DUP0:  {0},
	DUP1:  {0, 0},
	DUP2:  {0, 0, 0},
	SWAP1: {0, 0},
	SWAP2: {0, 0, 0},

	TGET: {1, 1},
	TSET: {1, 1, 0},
	TLEN: {1},

	BREAKPOINT: {},
	LOG:        {0},

	SEND:    {1},
	NBSEND:  {1},
	GETTIME: {},
	INBOX:   {0},
	ERROR:   {},
	HALT:    {},
	DEBUG:   {},
}