NET_add:                "Add two values, returning a new value"
NET_add_ovf:            "Add signed integer values with overflow check"
NET_add_ovf_un:         "Add unsigned integer values with overflow check"
NET_and:                "Bitwise AND of two integral values, returns an integral value"
//NET_ann_arg:
NET_ann_call:           "Start of simple calling sequence"
NET_ann_catch:          "Start an exception filter or handler"
NET_ann_data:           "Multi-byte no operation"
NET_ann_data_s:         "Multi-byte no operation, short form"
NET_ann_dead:           "Stack location is no longer live"
NET_ann_def:            "SSA definition node"
NET_ann_hoisted:        "Start of the simple portion of a hoisted calling sequence"
NET_ann_hoisted_call:   "Start of complex argument evaluation"
//NET_ann_lab:
NET_ann_live:           "Mark a stack location as live"
NET_ann_phi:            "SSA definition node"
NET_ann_ref:            "SSA reference node"
NET_ann_ref_s:          "SSA reference node, short form"
NET_arglist:            "Return argument list handle for the current method"
NET_beq:                "Branch to target if equal"
NET_beq_s:              "Branch to target if equal, short form"
NET_bge:                "Branch to target if greater than or equal to"
NET_bge_s:              "Branch to target if greater than or equal to, short form"
NET_bge_un:             "Branch to target if greater than or equal to (unsigned or unordered)"
NET_bge_un_s:           "Branch to target if greater than or equal to (unsigned or unordered), short form"
NET_bgt:                "Branch to target if greater than"
NET_bgt_s:              "Branch to target if greater than, short form"
NET_bgt_un:             "Branch to target if greater than (unsigned or unordered)"
NET_bgt_un_s:           "Branch to target if greater than (unsigned or unordered), short form"
NET_ble:                "Branch to target if less than or equal to"
NET_ble_s:              "Branch to target if less than or equal to, short form"
NET_ble_un:             "Branch to target if less than or equal to (unsigned or unordered)"
NET_ble_un_s:           "Branch to target if less than or equal to (unsigned or unordered), short form"
NET_blt:                "Branch to target if less than"
NET_blt_s:              "Branch to target if less than, short form"
NET_blt_un:             "Branch to target if less than (unsigned or unordered)"
NET_blt_un_s:           "Branch to target if less than (unsigned or unordered), short form"
NET_bne_un:             "Branch to target if unequal or unordered"
NET_bne_un_s:           "Branch to target if unequal or unordered, short form"
NET_box:                "Convert value type to object reference"
NET_br:                 "Branch to target"
NET_br_s:               "Branch to target, short form"
NET_break:              "Inform a debugger that a breakpoint has been reached"
NET_brfalse:            "Branch to target if value is zero (false)"
NET_brfalse_s:          "Branch to target if value is zero (false), short form"
NET_brtrue:             "Branch to target if value is non-zero (true)"
NET_brtrue_s:           "Branch to target if value is non-zero (true), short form"
NET_call:               "Call a method"
NET_calli:              "Call an indirect method"
NET_callvirt:           "Call a method associated with obj"
NET_castclass:          "Cast object to class"
NET_ceq:                "Push 1 (of type I4) if value1 equals value2, else 0"
NET_cgt:                "Push 1 (of type I4) if value1 > value2, else 0"
NET_cgt_un:             "Push 1 (of type I4) if value1 > value2, unsigned or unordered, else 0"
NET_ckfinite:           "Throw ArithmeticException if value is not a finite number"
NET_clt:                "Push 1 (of type I4) if value1 < value2, else 0"
NET_clt_un:             "Push 1 (of type I4) if value1 < value2, unsigned or unordered, else 0"
NET_conv_i:             "Convert to I, pushing I on stack"
NET_conv_i1:            "Convert to I1, pushing I4 on stack"
NET_conv_i2:            "Convert to I2, pushing I4 on stack"
NET_conv_i4:            "Convert to I4, pushing I4 on stack"
NET_conv_i8:            "Convert to I8, pushing I8 on stack"
NET_conv_ovf_i:         "Convert to an I (on the stack as I) and throw an exception on overflow"
NET_conv_ovf_i1:        "Convert to an I1 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i1_un:     "Convert unsigned to an I1 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i2:        "Convert to an I2 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i2_un:     "Convert unsigned to an I2 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i4:        "Convert to an I4 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i4_un:     "Convert unsigned to an I4 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_i8:        "Convert to an I8 (on the stack as I8) and throw an exception on overflow"
NET_conv_ovf_i8_un:     "Convert unsigned to an I8 (on the stack as I8) and throw an exception on overflow"
NET_conv_ovf_i_un:      "Convert to unsigned an I (on the stack as I) and throw an exception on overflow"
NET_conv_ovf_u:         "Convert to a U (on the stack as I) and throw an exception on overflow"
NET_conv_ovf_u1:        "Convert to a U1 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u1_un:     "Convert to unsigned a U1 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u2:        "Convert to a U2 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u2_un:     "Convert to unsigned a U2 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u4:        "Convert to a U4 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u4_un:     "Convert to unsigned a U3 (on the stack as I4) and throw an exception on overflow"
NET_conv_ovf_u8:        "Convert to a U8 (on the stack as I8) and throw an exception on overflow"
NET_conv_ovf_u8_un:     "Convert to unsigned a U8 (on the stack as I8) and throw an exception on overflow"
NET_conv_ovf_u_un:      "Convert to unsigned a U (on the stack as I) and throw an exception on overflow"
NET_conv_r4:            "Convert to R4, pushing F on stack"
NET_conv_r8:            "Convert to R8, pushing F on stack"
NET_conv_r_un:          "Convert unsigned integer to floating point, pushing F on stack"
NET_conv_u:             "Convert to U, pushing I on stack"
NET_conv_u1:            "Convert to U1, pushing I4 on stack"
NET_conv_u2:            "Convert to U2, pushing I4 on stack"
NET_conv_u4:            "Convert to U4, pushing I4 on stack"
NET_conv_u8:            "Convert to U8, pushing I8 on stack"
NET_cpblk:              "Copy data from memory to memory"
NET_cpobj:              "Copy a value type"
NET_div:                "Divide two values to return a quotient or floating point result"
NET_div_un:             "Divide two values, unsigned, returning a quotient"
NET_dup:                "Duplicate value on the top of the stack"
NET_endfilter:          "End filter clause of SEH exception handling"
NET_endfinally:         "End fault clause of an exception block"
NET_initblk:            "Set a block of memory to a given byte"
NET_initobj:            "Initialize a value type"
NET_isinst:             "Test if an object is an instance of a class or interface, returning NULL or an instance of that class or interface"
NET_jmp:                "Exit current method and jump to specified method"
NET_ldarg:              "Load argument numbered num onto stack"
NET_ldarg_0:            "Load argument 0 onto stack"
NET_ldarg_1:            "Load argument 1 onto stack"
NET_ldarg_2:            "Load argument 2 onto stack"
NET_ldarg_3:            "Load argument 3 onto stack"
NET_ldarg_s:            "Load argument numbered num onto stack, short form"
NET_ldarga:             "Fetch the address of argument"
NET_ldarga_s:           "Fetch the address of argument, short form"
NET_ldc_i4:             "Push num of type I4 onto the stack as I4"
NET_ldc_i4_0:           "Push 0 onto the stack as I4"
NET_ldc_i4_1:           "Push 1 onto the stack as I4"
NET_ldc_i4_2:           "Push 2 onto the stack as I4"
NET_ldc_i4_3:           "Push 3 onto the stack as I4"
NET_ldc_i4_4:           "Push 4 onto the stack as I4"
NET_ldc_i4_5:           "Push 5 onto the stack as I4"
NET_ldc_i4_6:           "Push 6 onto the stack as I4"
NET_ldc_i4_7:           "Push 7 onto the stack as I4"
NET_ldc_i4_8:           "Push 8 onto the stack as I4"
NET_ldc_i4_m1:          "Push -1 onto the stack as I4"
NET_ldc_i4_s:           "Push num onto the stack as I4, short form"
NET_ldc_i8:             "Push num of type I8 onto the stack as I8"
NET_ldc_r4:             "Push num of type R4 onto the stack as F"
NET_ldc_r8:             "Push num of type R8 onto the stack as F"
NET_ldelem_i:           "Load the element at index with type I onto the top of the stack as an I"
NET_ldelem_i1:          "Load the element at index with type I1 onto the top of the stack as an I4"
NET_ldelem_i2:          "Load the element at index with type I2 onto the top of the stack as an I4"
NET_ldelem_i4:          "Load the element at index with type I4 onto the top of the stack as an I4"
NET_ldelem_i8:          "Load the element at index with type I8 onto the top of the stack as an I8"
NET_ldelem_r4:          "Load the element at index with type R4 onto the top of the stack as an F"
NET_ldelem_r8:          "Load the element at index with type R8 onto the top of the stack as an F"
NET_ldelem_ref:         "Load the element at index, an object, onto the top of the stack as an O"
NET_ldelem_u1:          "Load the element at index with type U1 onto the top of the stack as an I4"
NET_ldelem_u2:          "Load the element at index with type U2 onto the top of the stack as an I4"
NET_ldelem_u4:          "Load the element at index with type U4 onto the top of the stack as an I4"
NET_ldelema:            "Load the address of element at index onto the top of the stack"
NET_ldfld:              "Push the value of field of object on the stack"
NET_ldflda:             "Push the address of field of object on the stack"
NET_ldftn:              "Push a pointer to a method referenced by method on the stack"
NET_ldind_i:            "Indirect load value of type I as I stack"
NET_ldind_i1:           "Indirect load value of type I1 as I4 on stack"
NET_ldind_i2:           "Indirect load value of type I2 as I4 on stack"
NET_ldind_i4:           "Indirect load value of type I4 as I4 on stack"
NET_ldind_i8:           "Indirect load value of type I8 as I8 on stack"
NET_ldind_r4:           "Indirect load value of type R4 as F stack"
NET_ldind_r8:           "Indirect load value of type R8 as F stack"
NET_ldind_ref:          "Indirect load value of type object ref as O on stack"
NET_ldind_u1:           "Indirect load value of type U1 as I4 stack"
NET_ldind_u2:           "Indirect load value of type U2 as I4 stack"
NET_ldind_u4:           "Indirect load value of type U4 as I4 stack"
NET_ldlen:              "Push the length (of type U) of array on the stack"
NET_ldloc:              "Load local variable of index indx onto stack"
NET_ldloc_0:            "Load local variable 0 onto stack"
NET_ldloc_1:            "Load local variable 1 onto stack"
NET_ldloc_2:            "Load local variable 2 onto stack"
NET_ldloc_3:            "Load local variable 3 onto stack"
NET_ldloc_s:            "Load local variable of index indx onto stack, short form"
NET_ldloca:             "Load address of local variable"
NET_ldloca_s:           "Load address of local variable, short form"
NET_ldnull:             "Push null GC reference on the stack"
NET_ldobj:              "Copy instance of value type to the stack."
NET_ldsfld:             "Push the value of field on the stack"
NET_ldsflda:            "Push the address of the static field on the stack"
NET_ldstr:              "Push a string object for the literal string"
NET_ldtoken:            "Convert metadata token to its runtime representation"
NET_ldvirtftn:          "Push address of virtual method on the stack"
NET_leave:              "Exit a protected region of code"
NET_leave_s:            "Exit a protected region of code, short form"
NET_localloc:           "Allocate space from the local memory pool"
NET_mkrefany:           "Push a typed reference to pointer of type class onto the stack"
NET_mul:                "Multiply values"
NET_mul_ovf:            "Multiply signed integer values. Signed result must fit in same size"
NET_mul_ovf_un:         "Multiply unsigned integer values. Unsigned result must fit in same size"
NET_neg:                "Negate value"
NET_newarr:             "Create a zero-based, one-dimensional array"
NET_newobj:             "Create a new object"
NET_nop:                "Do nothing"
NET_not:                "Bitwise complement"
NET_or:                 "Bitwise OR of two integer values, returns an integer"
NET_pop:                "Pop a value from the stack"
NET_refanytype:         "Push the type token stored in a typed reference"
NET_refanyval:          "Push the address stored in a typed reference"
NET_rem:                "Remainder of dividing value1 by value2"
NET_rem_un:             "Remainder of unsigned dividing value1 by value2"
NET_ret:                "Return from method, possibly returning a value"
NET_rethrow:            "Rethrow the current exception"
NET_shl:                "Shift an integer to the left (shifting in zeros)"
NET_shr:                "Shift an integer right, (shift in sign), return an integer"
NET_shr_un:             "Shift an integer right, (shift in zero), return an integer"
NET_sizeof:             "Push the size, in bytes, of a value type as a U4"
NET_starg:              "Store a value to argument"
NET_starg_s:            "Store a value to argument, short form"
NET_stelem_i:           "Replace array element at index with the I value on the stack"
NET_stelem_i1:          "Replace array element at index with the I1 value on the stack"
NET_stelem_i2:          "Replace array element at index with the I2 value on the stack"
NET_stelem_i4:          "Replace array element at index with the I4 value on the stack"
NET_stelem_i8:          "Replace array element at index with the I8 value on the stack"
NET_stelem_r4:          "Replace array element at index with the R4 value on the stack"
NET_stelem_r8:          "Replace array element at index with the R8 value on the stack"
NET_stelem_ref:         "Replace array element at index with the ref value on the stack"
NET_stfld:              "Store into a field of an object"
NET_stind_i:            "Store value of type I into memory at address"
NET_stind_i1:           "Store value of type I1 into memory at address"
NET_stind_i2:           "Store value of type I2 into memory at address"
NET_stind_i4:           "Store value of type I4 into memory at address"
NET_stind_i8:           "Store value of type I8 into memory at address"
NET_stind_r4:           "Store value of type R4 into memory at address"
NET_stind_r8:           "Store value of type R8 into memory at address"
NET_stind_ref:          "Store value of type object ref (type O) into memory at address"
NET_stloc:              "Pop value from stack into local variable"
NET_stloc_0:            "Pop value from stack into local variable 0"
NET_stloc_1:            "Pop value from stack into local variable 1"
NET_stloc_2:            "Pop value from stack into local variable 2"
NET_stloc_3:            "Pop value from stack into local variable 3"
NET_stloc_s:            "Pop value from stack into local variable, short form"
NET_stobj:              "Store a value type from the stack into memory"
NET_stsfld:             "Store a static field of a class"
NET_sub:                "Subtract value2 from value1, returning a new value"
NET_sub_ovf:            "Subtract I from an I. Signed result must fit in same size"
NET_sub_ovf_un:         "Subtract U from a U. Unsigned result must fit in same size"
NET_switch:             "Jump to one of N values"
NET_tail_:              "(prefix) subsequent call terminates current method"
NET_throw:              "Throw an exception"
NET_unaligned_:         "(prefix) subsequent pointer instruction may be unaligned"
NET_unbox:              "Convert boxed value type to its raw form"
NET_volatile_:          "(prefix) subsequent pointer reference is volatile"
NET_xor:                "Bitwise XOR of integer values, returns an integer"
NET_ldelem:             "Load the element at index onto the top of the stack"
NET_stelem:             "Replace array element at index with the ref value on the stack"

// 2.0 instructions
NET_unbox_any:          "Extract a value-type from obj, its boxed representation"
NET_constrained_:       "(prefix) invoke a member on a value of a variable type"
NET_no_:                "(prefix) possibly skip a fault check"
NET_readonly_:          "(prefix) following instruction returns a controlled-mutability managed pointer"