#include <stdio.h>
#include <assert.h>

enum opcodetype
{
    // push value
    OP_0=0,
    OP_FALSE=OP_0,
    OP_PUSHDATA1=76,
    OP_PUSHDATA2,
    OP_PUSHDATA4,
    OP_1NEGATE,
    OP_RESERVED,
    OP_1,
    OP_TRUE=OP_1,
    OP_2,
    OP_3,
    OP_4,
    OP_5,
    OP_6,
    OP_7,
    OP_8,
    OP_9,
    OP_10,
    OP_11,
    OP_12,
    OP_13,
    OP_14,
    OP_15,
    OP_16,

    // control
    OP_NOP,
    OP_VER,
    OP_IF,
    OP_NOTIF,
    OP_VERIF,
    OP_VERNOTIF,
    OP_ELSE,
    OP_ENDIF,
    OP_VERIFY,
    OP_RETURN,

    // stack ops
    OP_TOALTSTACK,
    OP_FROMALTSTACK,
    OP_2DROP,
    OP_2DUP,
    OP_3DUP,
    OP_2OVER,
    OP_2ROT,
    OP_2SWAP,
    OP_IFDUP,
    OP_DEPTH,
    OP_DROP,
    OP_DUP,
    OP_NIP,
    OP_OVER,
    OP_PICK,
    OP_ROLL,
    OP_ROT,
    OP_SWAP,
    OP_TUCK,

    // splice ops
    OP_CAT,
    OP_SUBSTR,
    OP_LEFT,
    OP_RIGHT,
    OP_SIZE,

    // bit logic
    OP_INVERT,
    OP_AND,
    OP_OR,
    OP_XOR,
    OP_EQUAL,
    OP_EQUALVERIFY,
    OP_RESERVED1,
    OP_RESERVED2,

    // numeric
    OP_1ADD,
    OP_1SUB,
    OP_2MUL,
    OP_2DIV,
    OP_NEGATE,
    OP_ABS,
    OP_NOT,
    OP_0NOTEQUAL,

    OP_ADD,
    OP_SUB,
    OP_MUL,
    OP_DIV,
    OP_MOD,
    OP_LSHIFT,
    OP_RSHIFT,

    OP_BOOLAND,
    OP_BOOLOR,
    OP_NUMEQUAL,
    OP_NUMEQUALVERIFY,
    OP_NUMNOTEQUAL,
    OP_LESSTHAN,
    OP_GREATERTHAN,
    OP_LESSTHANOREQUAL,
    OP_GREATERTHANOREQUAL,
    OP_MIN,
    OP_MAX,

    OP_WITHIN,

    // crypto
    OP_RIPEMD160,
    OP_SHA1,
    OP_SHA256,
    OP_HASH160,
    OP_HASH256,
    OP_CODESEPARATOR,
    OP_CHECKSIG,
    OP_CHECKSIGVERIFY,
    OP_CHECKMULTISIG,
    OP_CHECKMULTISIGVERIFY,

    // expansion
    OP_NOP1,
    OP_NOP2,
    OP_NOP3,
    OP_NOP4,
    OP_NOP5,
    OP_NOP6,
    OP_NOP7,
    OP_NOP8,
    OP_NOP9,
    OP_NOP10,



    // template matching params
    OP_SMALLINTEGER = 0xfa,
    OP_PUBKEYS = 0xfb,
    OP_PUBKEYHASH = 0xfd,
    OP_PUBKEY = 0xfe,

    OP_INVALIDOPCODE = 0xff,
};

enum opcodetype_new
{
    // push value
    NEW_OP_0 = 0x00,
    NEW_OP_FALSE = NEW_OP_0,
    NEW_OP_PUSHDATA1 = 0x4c,
    NEW_OP_PUSHDATA2 = 0x4d,
    NEW_OP_PUSHDATA4 = 0x4e,
    NEW_OP_1NEGATE = 0x4f,
    NEW_OP_RESERVED = 0x50,
    NEW_OP_1 = 0x51,
    NEW_OP_TRUE=NEW_OP_1,
    NEW_OP_2 = 0x52,
    NEW_OP_3 = 0x53,
    NEW_OP_4 = 0x54,
    NEW_OP_5 = 0x55,
    NEW_OP_6 = 0x56,
    NEW_OP_7 = 0x57,
    NEW_OP_8 = 0x58,
    NEW_OP_9 = 0x59,
    NEW_OP_10 = 0x5a,
    NEW_OP_11 = 0x5b,
    NEW_OP_12 = 0x5c,
    NEW_OP_13 = 0x5d,
    NEW_OP_14 = 0x5e,
    NEW_OP_15 = 0x5f,
    NEW_OP_16 = 0x60,

    // control
    NEW_OP_NOP = 0x61,
    NEW_OP_VER = 0x62,
    NEW_OP_IF = 0x63,
    NEW_OP_NOTIF = 0x64,
    NEW_OP_VERIF = 0x65,
    NEW_OP_VERNOTIF = 0x66,
    NEW_OP_ELSE = 0x67,
    NEW_OP_ENDIF = 0x68,
    NEW_OP_VERIFY = 0x69,
    NEW_OP_RETURN = 0x6a,

    // stack ops
    NEW_OP_TOALTSTACK = 0x6b,
    NEW_OP_FROMALTSTACK = 0x6c,
    NEW_OP_2DROP = 0x6d,
    NEW_OP_2DUP = 0x6e,
    NEW_OP_3DUP = 0x6f,
    NEW_OP_2OVER = 0x70,
    NEW_OP_2ROT = 0x71,
    NEW_OP_2SWAP = 0x72,
    NEW_OP_IFDUP = 0x73,
    NEW_OP_DEPTH = 0x74,
    NEW_OP_DROP = 0x75,
    NEW_OP_DUP = 0x76,
    NEW_OP_NIP = 0x77,
    NEW_OP_OVER = 0x78,
    NEW_OP_PICK = 0x79,
    NEW_OP_ROLL = 0x7a,
    NEW_OP_ROT = 0x7b,
    NEW_OP_SWAP = 0x7c,
    NEW_OP_TUCK = 0x7d,

    // splice ops
    NEW_OP_CAT = 0x7e,
    NEW_OP_SUBSTR = 0x7f,
    NEW_OP_LEFT = 0x80,
    NEW_OP_RIGHT = 0x81,
    NEW_OP_SIZE = 0x82,

    // bit logic
    NEW_OP_INVERT = 0x83,
    NEW_OP_AND = 0x84,
    NEW_OP_OR = 0x85,
    NEW_OP_XOR = 0x86,
    NEW_OP_EQUAL = 0x87,
    NEW_OP_EQUALVERIFY = 0x88,
    NEW_OP_RESERVED1 = 0x89,
    NEW_OP_RESERVED2 = 0x8a,

    // numeric
    NEW_OP_1ADD = 0x8b,
    NEW_OP_1SUB = 0x8c,
    NEW_OP_2MUL = 0x8d,
    NEW_OP_2DIV = 0x8e,
    NEW_OP_NEGATE = 0x8f,
    NEW_OP_ABS = 0x90,
    NEW_OP_NOT = 0x91,
    NEW_OP_0NOTEQUAL = 0x92,

    NEW_OP_ADD = 0x93,
    NEW_OP_SUB = 0x94,
    NEW_OP_MUL = 0x95,
    NEW_OP_DIV = 0x96,
    NEW_OP_MOD = 0x97,
    NEW_OP_LSHIFT = 0x98,
    NEW_OP_RSHIFT = 0x99,

    NEW_OP_BOOLAND = 0x9a,
    NEW_OP_BOOLOR = 0x9b,
    NEW_OP_NUMEQUAL = 0x9c,
    NEW_OP_NUMEQUALVERIFY = 0x9d,
    NEW_OP_NUMNOTEQUAL = 0x9e,
    NEW_OP_LESSTHAN = 0x9f,
    NEW_OP_GREATERTHAN = 0xa0,
    NEW_OP_LESSTHANOREQUAL = 0xa1,
    NEW_OP_GREATERTHANOREQUAL = 0xa2,
    NEW_OP_MIN = 0xa3,
    NEW_OP_MAX = 0xa4,

    NEW_OP_WITHIN = 0xa5,

    // crypto
    NEW_OP_RIPEMD160 = 0xa6,
    NEW_OP_SHA1 = 0xa7,
    NEW_OP_SHA256 = 0xa8,
    NEW_OP_HASH160 = 0xa9,
    NEW_OP_HASH256 = 0xaa,
    NEW_OP_CODESEPARATOR = 0xab,
    NEW_OP_CHECKSIG = 0xac,
    NEW_OP_CHECKSIGVERIFY = 0xad,
    NEW_OP_CHECKMULTISIG = 0xae,
    NEW_OP_CHECKMULTISIGVERIFY = 0xaf,

    // expansion
    NEW_OP_NOP1 = 0xb0,
    NEW_OP_NOP2 = 0xb1,
    NEW_OP_NOP3 = 0xb2,
    NEW_OP_NOP4 = 0xb3,
    NEW_OP_NOP5 = 0xb4,
    NEW_OP_NOP6 = 0xb5,
    NEW_OP_NOP7 = 0xb6,
    NEW_OP_NOP8 = 0xb7,
    NEW_OP_NOP9 = 0xb8,
    NEW_OP_NOP10 = 0xb9,



    // template matching params
    NEW_OP_SMALLINTEGER = 0xfa,
    NEW_OP_PUBKEYS = 0xfb,
    NEW_OP_PUBKEYHASH = 0xfd,
    NEW_OP_PUBKEY = 0xfe,

    NEW_OP_INVALIDOPCODE = 0xff,
};


int main()
{
    assert(NEW_OP_0 == OP_0);
    assert(NEW_OP_FALSE == OP_FALSE);
    assert(NEW_OP_PUSHDATA1 == OP_PUSHDATA1);
    assert(NEW_OP_PUSHDATA2 == OP_PUSHDATA2);
    assert(NEW_OP_PUSHDATA4 == OP_PUSHDATA4);
    assert(NEW_OP_1NEGATE == OP_1NEGATE);
    assert(NEW_OP_RESERVED == OP_RESERVED);
    assert(NEW_OP_1 == OP_1);
    assert(NEW_OP_TRUE == OP_TRUE);
    assert(NEW_OP_2 == OP_2);
    assert(NEW_OP_3 == OP_3);
    assert(NEW_OP_4 == OP_4);
    assert(NEW_OP_5 == OP_5);
    assert(NEW_OP_6 == OP_6);
    assert(NEW_OP_7 == OP_7);
    assert(NEW_OP_8 == OP_8);
    assert(NEW_OP_9 == OP_9);
    assert(NEW_OP_10 == OP_10);
    assert(NEW_OP_11 == OP_11);
    assert(NEW_OP_12 == OP_12);
    assert(NEW_OP_13 == OP_13);
    assert(NEW_OP_14 == OP_14);
    assert(NEW_OP_15 == OP_15);
    assert(NEW_OP_16 == OP_16);

    // control
    assert(NEW_OP_NOP == OP_NOP);
    assert(NEW_OP_VER == OP_VER);
    assert(NEW_OP_IF == OP_IF);
    assert(NEW_OP_NOTIF == OP_NOTIF);
    assert(NEW_OP_VERIF == OP_VERIF);
    assert(NEW_OP_VERNOTIF == OP_VERNOTIF);
    assert(NEW_OP_ELSE == OP_ELSE);
    assert(NEW_OP_ENDIF == OP_ENDIF);
    assert(NEW_OP_VERIFY == OP_VERIFY);
    assert(NEW_OP_RETURN == OP_RETURN);

    // stack ops
    assert(NEW_OP_TOALTSTACK == OP_TOALTSTACK);
    assert(NEW_OP_FROMALTSTACK == OP_FROMALTSTACK);
    assert(NEW_OP_2DROP == OP_2DROP);
    assert(NEW_OP_2DUP == OP_2DUP);
    assert(NEW_OP_3DUP == OP_3DUP);
    assert(NEW_OP_2OVER == OP_2OVER);
    assert(NEW_OP_2ROT == OP_2ROT);
    assert(NEW_OP_2SWAP == OP_2SWAP);
    assert(NEW_OP_IFDUP == OP_IFDUP);
    assert(NEW_OP_DEPTH == OP_DEPTH);
    assert(NEW_OP_DROP == OP_DROP);
    assert(NEW_OP_DUP == OP_DUP);
    assert(NEW_OP_NIP == OP_NIP);
    assert(NEW_OP_OVER == OP_OVER);
    assert(NEW_OP_PICK == OP_PICK);
    assert(NEW_OP_ROLL == OP_ROLL);
    assert(NEW_OP_ROT == OP_ROT);
    assert(NEW_OP_SWAP == OP_SWAP);
    assert(NEW_OP_TUCK == OP_TUCK);

    // splice ops
    assert(NEW_OP_CAT == OP_CAT);
    assert(NEW_OP_SUBSTR == OP_SUBSTR);
    assert(NEW_OP_LEFT == OP_LEFT);
    assert(NEW_OP_RIGHT == OP_RIGHT);
    assert(NEW_OP_SIZE == OP_SIZE);

    // bit logic
    assert(NEW_OP_INVERT == OP_INVERT);
    assert(NEW_OP_AND == OP_AND);
    assert(NEW_OP_OR == OP_OR);
    assert(NEW_OP_XOR == OP_XOR);
    assert(NEW_OP_EQUAL == OP_EQUAL);
    assert(NEW_OP_EQUALVERIFY == OP_EQUALVERIFY);
    assert(NEW_OP_RESERVED1 == OP_RESERVED1);
    assert(NEW_OP_NEGATE == OP_NEGATE);
    assert(NEW_OP_ABS == OP_ABS);
    assert(NEW_OP_NOT == OP_NOT);
    assert(NEW_OP_0NOTEQUAL == OP_0NOTEQUAL);

    assert(NEW_OP_ADD == OP_ADD);
    assert(NEW_OP_SUB == OP_SUB);
    assert(NEW_OP_MUL == OP_MUL);
    assert(NEW_OP_DIV == OP_DIV);
    assert(NEW_OP_MOD == OP_MOD);
    assert(NEW_OP_LSHIFT == OP_LSHIFT);
    assert(NEW_OP_RSHIFT == OP_RSHIFT);

    assert(NEW_OP_BOOLAND == OP_BOOLAND);
    assert(NEW_OP_BOOLOR == OP_BOOLOR);
    assert(NEW_OP_NUMEQUAL == OP_NUMEQUAL);
    assert(NEW_OP_NUMEQUALVERIFY == OP_NUMEQUALVERIFY);
    assert(NEW_OP_NUMNOTEQUAL == OP_NUMNOTEQUAL);
    assert(NEW_OP_LESSTHAN == OP_LESSTHAN);
    assert(NEW_OP_GREATERTHAN == OP_GREATERTHAN);
    assert(NEW_OP_LESSTHANOREQUAL == OP_LESSTHANOREQUAL);
    assert(NEW_OP_GREATERTHANOREQUAL == OP_GREATERTHANOREQUAL);
    assert(NEW_OP_MIN == OP_MIN);
    assert(NEW_OP_MAX == OP_MAX);

    assert(NEW_OP_WITHIN == OP_WITHIN);

    // crypto
    assert(NEW_OP_RIPEMD160 == OP_RIPEMD160);
    assert(NEW_OP_SHA1 == OP_SHA1);
    assert(NEW_OP_SHA256 == OP_SHA256);
    assert(NEW_OP_HASH160 == OP_HASH160);
    assert(NEW_OP_HASH256 == OP_HASH256);
    assert(NEW_OP_CODESEPARATOR == OP_CODESEPARATOR);
    assert(NEW_OP_CHECKSIG == OP_CHECKSIG);
    assert(NEW_OP_CHECKSIGVERIFY == OP_CHECKSIGVERIFY);
    assert(NEW_OP_CHECKMULTISIG == OP_CHECKMULTISIG);
    assert(NEW_OP_CHECKMULTISIGVERIFY == OP_CHECKMULTISIGVERIFY);

    // expansion
    assert(NEW_OP_NOP1 == OP_NOP1);
    assert(NEW_OP_NOP2 == OP_NOP2);
    assert(NEW_OP_NOP3 == OP_NOP3);
    assert(NEW_OP_NOP4 == OP_NOP4);
    assert(NEW_OP_NOP5 == OP_NOP5);
    assert(NEW_OP_NOP6 == OP_NOP6);
    assert(NEW_OP_NOP7 == OP_NOP7);
    assert(NEW_OP_NOP8 == OP_NOP8);
    assert(NEW_OP_NOP9 == OP_NOP9);
    assert(NEW_OP_NOP10 == OP_NOP10);



    // template matching params
    assert(NEW_OP_SMALLINTEGER == OP_SMALLINTEGER);
    assert(NEW_OP_PUBKEYS == OP_PUBKEYS);
    assert(NEW_OP_PUBKEYHASH == OP_PUBKEYHASH);
    assert(NEW_OP_PUBKEY == OP_PUBKEY);

    assert(NEW_OP_INVALIDOPCODE == OP_INVALIDOPCODE);


    printf("success\n");
}