diff --git a/src/blockdata/opcodes.rs b/src/blockdata/opcodes.rs
index 70807350..770d472b 100644
--- a/src/blockdata/opcodes.rs
+++ b/src/blockdata/opcodes.rs
@@ -33,542 +33,544 @@ use consensus::encode::{Decodable, Encodable};
 
 /// A script Opcode
 #[derive(Copy, Clone, PartialEq, Eq)]
-pub struct All(u8);
+pub struct All {
+    code: u8,
+}
 
 pub mod all {
   //! Constants associated with All type
   use super::All;
 
   /// Push an empty array onto the stack
-  pub const OP_PUSHBYTES_0: All = All(0x0);
+  pub const OP_PUSHBYTES_0: All = All {code: 0x00};
   /// Push the next byte as an array onto the stack
-  pub const OP_PUSHBYTES_1: All = All(0x01);
+  pub const OP_PUSHBYTES_1: All = All {code: 0x01};
   /// Push the next 2 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_2: All = All(0x02);
+  pub const OP_PUSHBYTES_2: All = All {code: 0x02};
   /// Push the next 2 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_3: All = All(0x03);
+  pub const OP_PUSHBYTES_3: All = All {code: 0x03};
   /// Push the next 4 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_4: All = All(0x04);
+  pub const OP_PUSHBYTES_4: All = All {code: 0x04};
   /// Push the next 5 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_5: All = All(0x05);
+  pub const OP_PUSHBYTES_5: All = All {code: 0x05};
   /// Push the next 6 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_6: All = All(0x06);
+  pub const OP_PUSHBYTES_6: All = All {code: 0x06};
   /// Push the next 7 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_7: All = All(0x07);
+  pub const OP_PUSHBYTES_7: All = All {code: 0x07};
   /// Push the next 8 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_8: All = All(0x08);
+  pub const OP_PUSHBYTES_8: All = All {code: 0x08};
   /// Push the next 9 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_9: All = All(0x09);
+  pub const OP_PUSHBYTES_9: All = All {code: 0x09};
   /// Push the next 10 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_10: All = All(0x0a);
+  pub const OP_PUSHBYTES_10: All = All {code: 0x0a};
   /// Push the next 11 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_11: All = All(0x0b);
+  pub const OP_PUSHBYTES_11: All = All {code: 0x0b};
   /// Push the next 12 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_12: All = All(0x0c);
+  pub const OP_PUSHBYTES_12: All = All {code: 0x0c};
   /// Push the next 13 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_13: All = All(0x0d);
+  pub const OP_PUSHBYTES_13: All = All {code: 0x0d};
   /// Push the next 14 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_14: All = All(0x0e);
+  pub const OP_PUSHBYTES_14: All = All {code: 0x0e};
   /// Push the next 15 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_15: All = All(0x0f);
+  pub const OP_PUSHBYTES_15: All = All {code: 0x0f};
   /// Push the next 16 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_16: All = All(0x10);
+  pub const OP_PUSHBYTES_16: All = All {code: 0x10};
   /// Push the next 17 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_17: All = All(0x11);
+  pub const OP_PUSHBYTES_17: All = All {code: 0x11};
   /// Push the next 18 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_18: All = All(0x12);
+  pub const OP_PUSHBYTES_18: All = All {code: 0x12};
   /// Push the next 19 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_19: All = All(0x13);
+  pub const OP_PUSHBYTES_19: All = All {code: 0x13};
   /// Push the next 20 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_20: All = All(0x14);
+  pub const OP_PUSHBYTES_20: All = All {code: 0x14};
   /// Push the next 21 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_21: All = All(0x15);
+  pub const OP_PUSHBYTES_21: All = All {code: 0x15};
   /// Push the next 22 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_22: All = All(0x16);
+  pub const OP_PUSHBYTES_22: All = All {code: 0x16};
   /// Push the next 23 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_23: All = All(0x17);
+  pub const OP_PUSHBYTES_23: All = All {code: 0x17};
   /// Push the next 24 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_24: All = All(0x18);
+  pub const OP_PUSHBYTES_24: All = All {code: 0x18};
   /// Push the next 25 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_25: All = All(0x19);
+  pub const OP_PUSHBYTES_25: All = All {code: 0x19};
   /// Push the next 26 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_26: All = All(0x1a);
+  pub const OP_PUSHBYTES_26: All = All {code: 0x1a};
   /// Push the next 27 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_27: All = All(0x1b);
+  pub const OP_PUSHBYTES_27: All = All {code: 0x1b};
   /// Push the next 28 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_28: All = All(0x1c);
+  pub const OP_PUSHBYTES_28: All = All {code: 0x1c};
   /// Push the next 29 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_29: All = All(0x1d);
+  pub const OP_PUSHBYTES_29: All = All {code: 0x1d};
   /// Push the next 30 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_30: All = All(0x1e);
+  pub const OP_PUSHBYTES_30: All = All {code: 0x1e};
   /// Push the next 31 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_31: All = All(0x1f);
+  pub const OP_PUSHBYTES_31: All = All {code: 0x1f};
   /// Push the next 32 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_32: All = All(0x20);
+  pub const OP_PUSHBYTES_32: All = All {code: 0x20};
   /// Push the next 33 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_33: All = All(0x21);
+  pub const OP_PUSHBYTES_33: All = All {code: 0x21};
   /// Push the next 34 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_34: All = All(0x22);
+  pub const OP_PUSHBYTES_34: All = All {code: 0x22};
   /// Push the next 35 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_35: All = All(0x23);
+  pub const OP_PUSHBYTES_35: All = All {code: 0x23};
   /// Push the next 36 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_36: All = All(0x24);
+  pub const OP_PUSHBYTES_36: All = All {code: 0x24};
   /// Push the next 37 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_37: All = All(0x25);
+  pub const OP_PUSHBYTES_37: All = All {code: 0x25};
   /// Push the next 38 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_38: All = All(0x26);
+  pub const OP_PUSHBYTES_38: All = All {code: 0x26};
   /// Push the next 39 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_39: All = All(0x27);
+  pub const OP_PUSHBYTES_39: All = All {code: 0x27};
   /// Push the next 40 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_40: All = All(0x28);
+  pub const OP_PUSHBYTES_40: All = All {code: 0x28};
   /// Push the next 41 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_41: All = All(0x29);
+  pub const OP_PUSHBYTES_41: All = All {code: 0x29};
   /// Push the next 42 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_42: All = All(0x2a);
+  pub const OP_PUSHBYTES_42: All = All {code: 0x2a};
   /// Push the next 43 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_43: All = All(0x2b);
+  pub const OP_PUSHBYTES_43: All = All {code: 0x2b};
   /// Push the next 44 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_44: All = All(0x2c);
+  pub const OP_PUSHBYTES_44: All = All {code: 0x2c};
   /// Push the next 45 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_45: All = All(0x2d);
+  pub const OP_PUSHBYTES_45: All = All {code: 0x2d};
   /// Push the next 46 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_46: All = All(0x2e);
+  pub const OP_PUSHBYTES_46: All = All {code: 0x2e};
   /// Push the next 47 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_47: All = All(0x2f);
+  pub const OP_PUSHBYTES_47: All = All {code: 0x2f};
   /// Push the next 48 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_48: All = All(0x30);
+  pub const OP_PUSHBYTES_48: All = All {code: 0x30};
   /// Push the next 49 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_49: All = All(0x31);
+  pub const OP_PUSHBYTES_49: All = All {code: 0x31};
   /// Push the next 50 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_50: All = All(0x32);
+  pub const OP_PUSHBYTES_50: All = All {code: 0x32};
   /// Push the next 51 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_51: All = All(0x33);
+  pub const OP_PUSHBYTES_51: All = All {code: 0x33};
   /// Push the next 52 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_52: All = All(0x34);
+  pub const OP_PUSHBYTES_52: All = All {code: 0x34};
   /// Push the next 53 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_53: All = All(0x35);
+  pub const OP_PUSHBYTES_53: All = All {code: 0x35};
   /// Push the next 54 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_54: All = All(0x36);
+  pub const OP_PUSHBYTES_54: All = All {code: 0x36};
   /// Push the next 55 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_55: All = All(0x37);
+  pub const OP_PUSHBYTES_55: All = All {code: 0x37};
   /// Push the next 56 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_56: All = All(0x38);
+  pub const OP_PUSHBYTES_56: All = All {code: 0x38};
   /// Push the next 57 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_57: All = All(0x39);
+  pub const OP_PUSHBYTES_57: All = All {code: 0x39};
   /// Push the next 58 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_58: All = All(0x3a);
+  pub const OP_PUSHBYTES_58: All = All {code: 0x3a};
   /// Push the next 59 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_59: All = All(0x3b);
+  pub const OP_PUSHBYTES_59: All = All {code: 0x3b};
   /// Push the next 60 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_60: All = All(0x3c);
+  pub const OP_PUSHBYTES_60: All = All {code: 0x3c};
   /// Push the next 61 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_61: All = All(0x3d);
+  pub const OP_PUSHBYTES_61: All = All {code: 0x3d};
   /// Push the next 62 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_62: All = All(0x3e);
+  pub const OP_PUSHBYTES_62: All = All {code: 0x3e};
   /// Push the next 63 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_63: All = All(0x3f);
+  pub const OP_PUSHBYTES_63: All = All {code: 0x3f};
   /// Push the next 64 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_64: All = All(0x40);
+  pub const OP_PUSHBYTES_64: All = All {code: 0x40};
   /// Push the next 65 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_65: All = All(0x41);
+  pub const OP_PUSHBYTES_65: All = All {code: 0x41};
   /// Push the next 66 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_66: All = All(0x42);
+  pub const OP_PUSHBYTES_66: All = All {code: 0x42};
   /// Push the next 67 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_67: All = All(0x43);
+  pub const OP_PUSHBYTES_67: All = All {code: 0x43};
   /// Push the next 68 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_68: All = All(0x44);
+  pub const OP_PUSHBYTES_68: All = All {code: 0x44};
   /// Push the next 69 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_69: All = All(0x45);
+  pub const OP_PUSHBYTES_69: All = All {code: 0x45};
   /// Push the next 70 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_70: All = All(0x46);
+  pub const OP_PUSHBYTES_70: All = All {code: 0x46};
   /// Push the next 71 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_71: All = All(0x47);
+  pub const OP_PUSHBYTES_71: All = All {code: 0x47};
   /// Push the next 72 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_72: All = All(0x48);
+  pub const OP_PUSHBYTES_72: All = All {code: 0x48};
   /// Push the next 73 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_73: All = All(0x49);
+  pub const OP_PUSHBYTES_73: All = All {code: 0x49};
   /// Push the next 74 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_74: All = All(0x4a);
+  pub const OP_PUSHBYTES_74: All = All {code: 0x4a};
   /// Push the next 75 bytes as an array onto the stack
-  pub const OP_PUSHBYTES_75: All = All(0x4b);
+  pub const OP_PUSHBYTES_75: All = All {code: 0x4b};
   /// Read the next byte as N; push the next N bytes as an array onto the stack
-  pub const OP_PUSHDATA1: All = All(0x4c);
+  pub const OP_PUSHDATA1: All = All {code: 0x4c};
   /// Read the next 2 bytes as N; push the next N bytes as an array onto the stack
-  pub const OP_PUSHDATA2: All = All(0x4d);
+  pub const OP_PUSHDATA2: All = All {code: 0x4d};
   /// Read the next 4 bytes as N; push the next N bytes as an array onto the stack
-  pub const OP_PUSHDATA4: All = All(0x4e);
+  pub const OP_PUSHDATA4: All = All {code: 0x4e};
   /// Push the array [0x81] onto the stack
-  pub const OP_PUSHNUM_NEG1: All = All(0x4f);
+  pub const OP_PUSHNUM_NEG1: All = All {code: 0x4f};
   /// Synonym for OP_RETURN
-  pub const OP_RESERVED: All = All(0x50);
+  pub const OP_RESERVED: All = All {code: 0x50};
   /// Push the array [0x01] onto the stack
-  pub const OP_PUSHNUM_1: All = All(0x51);
+  pub const OP_PUSHNUM_1: All = All {code: 0x51};
   /// Push the array [0x02] onto the stack
-  pub const OP_PUSHNUM_2: All = All(0x52);
+  pub const OP_PUSHNUM_2: All = All {code: 0x52};
   /// Push the array [0x03] onto the stack
-  pub const OP_PUSHNUM_3: All = All(0x53);
+  pub const OP_PUSHNUM_3: All = All {code: 0x53};
   /// Push the array [0x04] onto the stack
-  pub const OP_PUSHNUM_4: All = All(0x54);
+  pub const OP_PUSHNUM_4: All = All {code: 0x54};
   /// Push the array [0x05] onto the stack
-  pub const OP_PUSHNUM_5: All = All(0x55);
+  pub const OP_PUSHNUM_5: All = All {code: 0x55};
   /// Push the array [0x06] onto the stack
-  pub const OP_PUSHNUM_6: All = All(0x56);
+  pub const OP_PUSHNUM_6: All = All {code: 0x56};
   /// Push the array [0x07] onto the stack
-  pub const OP_PUSHNUM_7: All = All(0x57);
+  pub const OP_PUSHNUM_7: All = All {code: 0x57};
   /// Push the array [0x08] onto the stack
-  pub const OP_PUSHNUM_8: All = All(0x58);
+  pub const OP_PUSHNUM_8: All = All {code: 0x58};
   /// Push the array [0x09] onto the stack
-  pub const OP_PUSHNUM_9: All = All(0x59);
+  pub const OP_PUSHNUM_9: All = All {code: 0x59};
   /// Push the array [0x0a] onto the stack
-  pub const OP_PUSHNUM_10: All = All(0x5a);
+  pub const OP_PUSHNUM_10: All = All {code: 0x5a};
   /// Push the array [0x0b] onto the stack
-  pub const OP_PUSHNUM_11: All = All(0x5b);
+  pub const OP_PUSHNUM_11: All = All {code: 0x5b};
   /// Push the array [0x0c] onto the stack
-  pub const OP_PUSHNUM_12: All = All(0x5c);
+  pub const OP_PUSHNUM_12: All = All {code: 0x5c};
   /// Push the array [0x0d] onto the stack
-  pub const OP_PUSHNUM_13: All = All(0x5d);
+  pub const OP_PUSHNUM_13: All = All {code: 0x5d};
   /// Push the array [0x0e] onto the stack
-  pub const OP_PUSHNUM_14: All = All(0x5e);
+  pub const OP_PUSHNUM_14: All = All {code: 0x5e};
   /// Push the array [0x0f] onto the stack
-  pub const OP_PUSHNUM_15: All = All(0x5f);
+  pub const OP_PUSHNUM_15: All = All {code: 0x5f};
   /// Push the array [0x10] onto the stack
-  pub const OP_PUSHNUM_16: All = All(0x60);
+  pub const OP_PUSHNUM_16: All = All {code: 0x60};
   /// Does nothing
-  pub const OP_NOP: All = All(0x61);
+  pub const OP_NOP: All = All {code: 0x61};
   /// Synonym for OP_RETURN
-  pub const OP_VER: All = All(0x62);
+  pub const OP_VER: All = All {code: 0x62};
   /// Pop and execute the next statements if a nonzero element was popped
-  pub const OP_IF: All = All(0x63);
+  pub const OP_IF: All = All {code: 0x63};
   /// Pop and execute the next statements if a zero element was popped
-  pub const OP_NOTIF: All = All(0x64);
+  pub const OP_NOTIF: All = All {code: 0x64};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_VERIF: All = All(0x65);
+  pub const OP_VERIF: All = All {code: 0x65};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_VERNOTIF: All = All(0x66);
+  pub const OP_VERNOTIF: All = All {code: 0x66};
   /// Execute statements if those after the previous OP_IF were not, and vice-versa.
   /// If there is no previous OP_IF, this acts as a RETURN.
-  pub const OP_ELSE: All = All(0x67);
+  pub const OP_ELSE: All = All {code: 0x67};
   /// Pop and execute the next statements if a zero element was popped
-  pub const OP_ENDIF: All = All(0x68);
+  pub const OP_ENDIF: All = All {code: 0x68};
   /// If the top value is zero or the stack is empty, fail; otherwise, pop the stack
-  pub const OP_VERIFY: All = All(0x69);
+  pub const OP_VERIFY: All = All {code: 0x69};
   /// Fail the script immediately. (Must be executed.)
-  pub const OP_RETURN: All = All(0x6a);
+  pub const OP_RETURN: All = All {code: 0x6a};
   /// Pop one element from the main stack onto the alt stack
-  pub const OP_TOALTSTACK: All = All(0x6b);
+  pub const OP_TOALTSTACK: All = All {code: 0x6b};
   /// Pop one element from the alt stack onto the main stack
-  pub const OP_FROMALTSTACK: All = All(0x6c);
+  pub const OP_FROMALTSTACK: All = All {code: 0x6c};
   /// Drops the top two stack items
-  pub const OP_2DROP: All = All(0x6d);
+  pub const OP_2DROP: All = All {code: 0x6d};
   /// Duplicates the top two stack items as AB -> ABAB
-  pub const OP_2DUP: All = All(0x6e);
+  pub const OP_2DUP: All = All {code: 0x6e};
   /// Duplicates the two three stack items as ABC -> ABCABC
-  pub const OP_3DUP: All = All(0x6f);
+  pub const OP_3DUP: All = All {code: 0x6f};
   /// Copies the two stack items of items two spaces back to
   /// the front, as xxAB -> ABxxAB
-  pub const OP_2OVER: All = All(0x70);
+  pub const OP_2OVER: All = All {code: 0x70};
   /// Moves the two stack items four spaces back to the front,
   /// as xxxxAB -> ABxxxx
-  pub const OP_2ROT: All = All(0x71);
+  pub const OP_2ROT: All = All {code: 0x71};
   /// Swaps the top two pairs, as ABCD -> CDAB
-  pub const OP_2SWAP: All = All(0x72);
+  pub const OP_2SWAP: All = All {code: 0x72};
   /// Duplicate the top stack element unless it is zero
-  pub const OP_IFDUP: All = All(0x73);
+  pub const OP_IFDUP: All = All {code: 0x73};
   /// Push the current number of stack items onto te stack
-  pub const OP_DEPTH: All = All(0x74);
+  pub const OP_DEPTH: All = All {code: 0x74};
   /// Drops the top stack item
-  pub const OP_DROP: All = All(0x75);
+  pub const OP_DROP: All = All {code: 0x75};
   /// Duplicates the top stack item
-  pub const OP_DUP: All = All(0x76);
+  pub const OP_DUP: All = All {code: 0x76};
   /// Drops the second-to-top stack item
-  pub const OP_NIP: All = All(0x77);
+  pub const OP_NIP: All = All {code: 0x77};
   /// Copies the second-to-top stack item, as xA -> AxA
-  pub const OP_OVER: All = All(0x78);
+  pub const OP_OVER: All = All {code: 0x78};
   /// Pop the top stack element as N. Copy the Nth stack element to the top
-  pub const OP_PICK: All = All(0x79);
+  pub const OP_PICK: All = All {code: 0x79};
   /// Pop the top stack element as N. Move the Nth stack element to the top
-  pub const OP_ROLL: All = All(0x7a);
+  pub const OP_ROLL: All = All {code: 0x7a};
   /// Rotate the top three stack items, as [top next1 next2] -> [next2 top next1]
-  pub const OP_ROT: All = All(0x7b);
+  pub const OP_ROT: All = All {code: 0x7b};
   /// Swap the top two stack items
-  pub const OP_SWAP: All = All(0x7c);
+  pub const OP_SWAP: All = All {code: 0x7c};
   /// Copy the top stack item to before the second item, as [top next] -> [top next top]
-  pub const OP_TUCK: All = All(0x7d);
+  pub const OP_TUCK: All = All {code: 0x7d};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_CAT: All = All(0x7e);
+  pub const OP_CAT: All = All {code: 0x7e};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_SUBSTR: All = All(0x7f);
+  pub const OP_SUBSTR: All = All {code: 0x7f};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_LEFT: All = All(0x80);
+  pub const OP_LEFT: All = All {code: 0x80};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_RIGHT: All = All(0x81);
+  pub const OP_RIGHT: All = All {code: 0x81};
   /// Pushes the length of the top stack item onto the stack
-  pub const OP_SIZE: All = All(0x82);
+  pub const OP_SIZE: All = All {code: 0x82};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_INVERT: All = All(0x83);
+  pub const OP_INVERT: All = All {code: 0x83};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_AND: All = All(0x84);
+  pub const OP_AND: All = All {code: 0x84};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_OR: All = All(0x85);
+  pub const OP_OR: All = All {code: 0x85};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_XOR: All = All(0x86);
+  pub const OP_XOR: All = All {code: 0x86};
   /// Pushes 1 if the inputs are exactly equal, 0 otherwise
-  pub const OP_EQUAL: All = All(0x87);
+  pub const OP_EQUAL: All = All {code: 0x87};
   /// Returns success if the inputs are exactly equal, failure otherwise
-  pub const OP_EQUALVERIFY: All = All(0x88);
+  pub const OP_EQUALVERIFY: All = All {code: 0x88};
   /// Synonym for OP_RETURN
-  pub const OP_RESERVED1: All = All(0x89);
+  pub const OP_RESERVED1: All = All {code: 0x89};
   /// Synonym for OP_RETURN
-  pub const OP_RESERVED2: All = All(0x8a);
+  pub const OP_RESERVED2: All = All {code: 0x8a};
   /// Increment the top stack element in place
-  pub const OP_1ADD: All = All(0x8b);
+  pub const OP_1ADD: All = All {code: 0x8b};
   /// Decrement the top stack element in place
-  pub const OP_1SUB: All = All(0x8c);
+  pub const OP_1SUB: All = All {code: 0x8c};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_2MUL: All = All(0x8d);
+  pub const OP_2MUL: All = All {code: 0x8d};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_2DIV: All = All(0x8e);
+  pub const OP_2DIV: All = All {code: 0x8e};
   /// Multiply the top stack item by -1 in place
-  pub const OP_NEGATE: All = All(0x8f);
+  pub const OP_NEGATE: All = All {code: 0x8f};
   /// Absolute value the top stack item in place
-  pub const OP_ABS: All = All(0x90);
+  pub const OP_ABS: All = All {code: 0x90};
   /// Map 0 to 1 and everything else to 0, in place
-  pub const OP_NOT: All = All(0x91);
+  pub const OP_NOT: All = All {code: 0x91};
   /// Map 0 to 0 and everything else to 1, in place
-  pub const OP_0NOTEQUAL: All = All(0x92);
+  pub const OP_0NOTEQUAL: All = All {code: 0x92};
   /// Pop two stack items and push their sum
-  pub const OP_ADD: All = All(0x93);
+  pub const OP_ADD: All = All {code: 0x93};
   /// Pop two stack items and push the second minus the top
-  pub const OP_SUB: All = All(0x94);
+  pub const OP_SUB: All = All {code: 0x94};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_MUL: All = All(0x95);
+  pub const OP_MUL: All = All {code: 0x95};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_DIV: All = All(0x96);
+  pub const OP_DIV: All = All {code: 0x96};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_MOD: All = All(0x97);
+  pub const OP_MOD: All = All {code: 0x97};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_LSHIFT: All = All(0x98);
+  pub const OP_LSHIFT: All = All {code: 0x98};
   /// Fail the script unconditionally, does not even need to be executed
-  pub const OP_RSHIFT: All = All(0x99);
+  pub const OP_RSHIFT: All = All {code: 0x99};
   /// Pop the top two stack items and push 1 if both are nonzero, else push 0
-  pub const OP_BOOLAND: All = All(0x9a);
+  pub const OP_BOOLAND: All = All {code: 0x9a};
   /// Pop the top two stack items and push 1 if either is nonzero, else push 0
-  pub const OP_BOOLOR: All = All(0x9b);
+  pub const OP_BOOLOR: All = All {code: 0x9b};
   /// Pop the top two stack items and push 1 if both are numerically equal, else push 0
-  pub const OP_NUMEQUAL: All = All(0x9c);
+  pub const OP_NUMEQUAL: All = All {code: 0x9c};
   /// Pop the top two stack items and return success if both are numerically equal, else return failure
-  pub const OP_NUMEQUALVERIFY: All = All(0x9d);
+  pub const OP_NUMEQUALVERIFY: All = All {code: 0x9d};
   /// Pop the top two stack items and push 0 if both are numerically equal, else push 1
-  pub const OP_NUMNOTEQUAL: All = All(0x9e);
+  pub const OP_NUMNOTEQUAL: All = All {code: 0x9e};
   /// Pop the top two items; push 1 if the second is less than the top, 0 otherwise
-  pub const OP_LESSTHAN : All = All(0x9f);
+  pub const OP_LESSTHAN : All = All {code: 0x9f};
   /// Pop the top two items; push 1 if the second is greater than the top, 0 otherwise
-  pub const OP_GREATERTHAN : All = All(0xa0);
+  pub const OP_GREATERTHAN : All = All {code: 0xa0};
   /// Pop the top two items; push 1 if the second is <= the top, 0 otherwise
-  pub const OP_LESSTHANOREQUAL : All = All(0xa1);
+  pub const OP_LESSTHANOREQUAL : All = All {code: 0xa1};
   /// Pop the top two items; push 1 if the second is >= the top, 0 otherwise
-  pub const OP_GREATERTHANOREQUAL : All = All(0xa2);
+  pub const OP_GREATERTHANOREQUAL : All = All {code: 0xa2};
   /// Pop the top two items; push the smaller
-  pub const OP_MIN: All = All(0xa3);
+  pub const OP_MIN: All = All {code: 0xa3};
   /// Pop the top two items; push the larger
-  pub const OP_MAX: All = All(0xa4);
+  pub const OP_MAX: All = All {code: 0xa4};
   /// Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0
-  pub const OP_WITHIN: All = All(0xa5);
+  pub const OP_WITHIN: All = All {code: 0xa5};
   /// Pop the top stack item and push its RIPEMD160 hash
-  pub const OP_RIPEMD160: All = All(0xa6);
+  pub const OP_RIPEMD160: All = All {code: 0xa6};
   /// Pop the top stack item and push its SHA1 hash
-  pub const OP_SHA1: All = All(0xa7);
+  pub const OP_SHA1: All = All {code: 0xa7};
   /// Pop the top stack item and push its SHA256 hash
-  pub const OP_SHA256: All = All(0xa8);
+  pub const OP_SHA256: All = All {code: 0xa8};
   /// Pop the top stack item and push its RIPEMD(SHA256) hash
-  pub const OP_HASH160: All = All(0xa9);
+  pub const OP_HASH160: All = All {code: 0xa9};
   /// Pop the top stack item and push its SHA256(SHA256) hash
-  pub const OP_HASH256: All = All(0xaa);
+  pub const OP_HASH256: All = All {code: 0xaa};
   /// Ignore this and everything preceding when deciding what to sign when signature-checking
-  pub const OP_CODESEPARATOR: All = All(0xab);
+  pub const OP_CODESEPARATOR: All = All {code: 0xab};
   /// https://en.bitcoin.it/wiki/OP_CHECKSIG pushing 1/0 for success/failure
-  pub const OP_CHECKSIG: All = All(0xac);
+  pub const OP_CHECKSIG: All = All {code: 0xac};
   /// https://en.bitcoin.it/wiki/OP_CHECKSIG returning success/failure
-  pub const OP_CHECKSIGVERIFY: All = All(0xad);
+  pub const OP_CHECKSIGVERIFY: All = All {code: 0xad};
   /// Pop N, N pubkeys, M, M signatures, a dummy (due to bug in reference code), and verify that all M signatures are valid.
   /// Push 1 for "all valid", 0 otherwise
-  pub const OP_CHECKMULTISIG: All = All(0xae);
+  pub const OP_CHECKMULTISIG: All = All {code: 0xae};
   /// Like the above but return success/failure
-  pub const OP_CHECKMULTISIGVERIFY: All = All(0xaf);
+  pub const OP_CHECKMULTISIGVERIFY: All = All {code: 0xaf};
   /// Does nothing
-  pub const OP_NOP1: All = All(0xb0);
+  pub const OP_NOP1: All = All {code: 0xb0};
   /// Does nothing
-  pub const OP_NOP2: All = All(0xb1);
+  pub const OP_NOP2: All = All {code: 0xb1};
   /// Does nothing
-  pub const OP_NOP3: All = All(0xb2);
+  pub const OP_NOP3: All = All {code: 0xb2};
   /// Does nothing
-  pub const OP_NOP4: All = All(0xb3);
+  pub const OP_NOP4: All = All {code: 0xb3};
   /// Does nothing
-  pub const OP_NOP5: All = All(0xb4);
+  pub const OP_NOP5: All = All {code: 0xb4};
   /// Does nothing
-  pub const OP_NOP6: All = All(0xb5);
+  pub const OP_NOP6: All = All {code: 0xb5};
   /// Does nothing
-  pub const OP_NOP7: All = All(0xb6);
+  pub const OP_NOP7: All = All {code: 0xb6};
   /// Does nothing
-  pub const OP_NOP8: All = All(0xb7);
+  pub const OP_NOP8: All = All {code: 0xb7};
   /// Does nothing
-  pub const OP_NOP9: All = All(0xb8);
+  pub const OP_NOP9: All = All {code: 0xb8};
   /// Does nothing
-  pub const OP_NOP10: All = All(0xb9);
+  pub const OP_NOP10: All = All {code: 0xb9};
   // Every other opcode acts as OP_RETURN
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_186: All = All(0xba);
+  pub const OP_RETURN_186: All = All {code: 0xba};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_187: All = All(0xbb);
+  pub const OP_RETURN_187: All = All {code: 0xbb};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_188: All = All(0xbc);
+  pub const OP_RETURN_188: All = All {code: 0xbc};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_189: All = All(0xbd);
+  pub const OP_RETURN_189: All = All {code: 0xbd};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_190: All = All(0xbe);
+  pub const OP_RETURN_190: All = All {code: 0xbe};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_191: All = All(0xbf);
+  pub const OP_RETURN_191: All = All {code: 0xbf};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_192: All = All(0xc0);
+  pub const OP_RETURN_192: All = All {code: 0xc0};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_193: All = All(0xc1);
+  pub const OP_RETURN_193: All = All {code: 0xc1};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_194: All = All(0xc2);
+  pub const OP_RETURN_194: All = All {code: 0xc2};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_195: All = All(0xc3);
+  pub const OP_RETURN_195: All = All {code: 0xc3};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_196: All = All(0xc4);
+  pub const OP_RETURN_196: All = All {code: 0xc4};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_197: All = All(0xc5);
+  pub const OP_RETURN_197: All = All {code: 0xc5};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_198: All = All(0xc6);
+  pub const OP_RETURN_198: All = All {code: 0xc6};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_199: All = All(0xc7);
+  pub const OP_RETURN_199: All = All {code: 0xc7};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_200: All = All(0xc8);
+  pub const OP_RETURN_200: All = All {code: 0xc8};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_201: All = All(0xc9);
+  pub const OP_RETURN_201: All = All {code: 0xc9};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_202: All = All(0xca);
+  pub const OP_RETURN_202: All = All {code: 0xca};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_203: All = All(0xcb);
+  pub const OP_RETURN_203: All = All {code: 0xcb};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_204: All = All(0xcc);
+  pub const OP_RETURN_204: All = All {code: 0xcc};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_205: All = All(0xcd);
+  pub const OP_RETURN_205: All = All {code: 0xcd};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_206: All = All(0xce);
+  pub const OP_RETURN_206: All = All {code: 0xce};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_207: All = All(0xcf);
+  pub const OP_RETURN_207: All = All {code: 0xcf};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_208: All = All(0xd0);
+  pub const OP_RETURN_208: All = All {code: 0xd0};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_209: All = All(0xd1);
+  pub const OP_RETURN_209: All = All {code: 0xd1};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_210: All = All(0xd2);
+  pub const OP_RETURN_210: All = All {code: 0xd2};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_211: All = All(0xd3);
+  pub const OP_RETURN_211: All = All {code: 0xd3};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_212: All = All(0xd4);
+  pub const OP_RETURN_212: All = All {code: 0xd4};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_213: All = All(0xd5);
+  pub const OP_RETURN_213: All = All {code: 0xd5};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_214: All = All(0xd6);
+  pub const OP_RETURN_214: All = All {code: 0xd6};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_215: All = All(0xd7);
+  pub const OP_RETURN_215: All = All {code: 0xd7};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_216: All = All(0xd8);
+  pub const OP_RETURN_216: All = All {code: 0xd8};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_217: All = All(0xd9);
+  pub const OP_RETURN_217: All = All {code: 0xd9};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_218: All = All(0xda);
+  pub const OP_RETURN_218: All = All {code: 0xda};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_219: All = All(0xdb);
+  pub const OP_RETURN_219: All = All {code: 0xdb};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_220: All = All(0xdc);
+  pub const OP_RETURN_220: All = All {code: 0xdc};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_221: All = All(0xdd);
+  pub const OP_RETURN_221: All = All {code: 0xdd};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_222: All = All(0xde);
+  pub const OP_RETURN_222: All = All {code: 0xde};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_223: All = All(0xdf);
+  pub const OP_RETURN_223: All = All {code: 0xdf};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_224: All = All(0xe0);
+  pub const OP_RETURN_224: All = All {code: 0xe0};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_225: All = All(0xe1);
+  pub const OP_RETURN_225: All = All {code: 0xe1};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_226: All = All(0xe2);
+  pub const OP_RETURN_226: All = All {code: 0xe2};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_227: All = All(0xe3);
+  pub const OP_RETURN_227: All = All {code: 0xe3};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_228: All = All(0xe4);
+  pub const OP_RETURN_228: All = All {code: 0xe4};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_229: All = All(0xe5);
+  pub const OP_RETURN_229: All = All {code: 0xe5};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_230: All = All(0xe6);
+  pub const OP_RETURN_230: All = All {code: 0xe6};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_231: All = All(0xe7);
+  pub const OP_RETURN_231: All = All {code: 0xe7};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_232: All = All(0xe8);
+  pub const OP_RETURN_232: All = All {code: 0xe8};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_233: All = All(0xe9);
+  pub const OP_RETURN_233: All = All {code: 0xe9};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_234: All = All(0xea);
+  pub const OP_RETURN_234: All = All {code: 0xea};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_235: All = All(0xeb);
+  pub const OP_RETURN_235: All = All {code: 0xeb};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_236: All = All(0xec);
+  pub const OP_RETURN_236: All = All {code: 0xec};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_237: All = All(0xed);
+  pub const OP_RETURN_237: All = All {code: 0xed};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_238: All = All(0xee);
+  pub const OP_RETURN_238: All = All {code: 0xee};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_239: All = All(0xef);
+  pub const OP_RETURN_239: All = All {code: 0xef};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_240: All = All(0xf0);
+  pub const OP_RETURN_240: All = All {code: 0xf0};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_241: All = All(0xf1);
+  pub const OP_RETURN_241: All = All {code: 0xf1};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_242: All = All(0xf2);
+  pub const OP_RETURN_242: All = All {code: 0xf2};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_243: All = All(0xf3);
+  pub const OP_RETURN_243: All = All {code: 0xf3};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_244: All = All(0xf4);
+  pub const OP_RETURN_244: All = All {code: 0xf4};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_245: All = All(0xf5);
+  pub const OP_RETURN_245: All = All {code: 0xf5};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_246: All = All(0xf6);
+  pub const OP_RETURN_246: All = All {code: 0xf6};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_247: All = All(0xf7);
+  pub const OP_RETURN_247: All = All {code: 0xf7};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_248: All = All(0xf8);
+  pub const OP_RETURN_248: All = All {code: 0xf8};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_249: All = All(0xf9);
+  pub const OP_RETURN_249: All = All {code: 0xf9};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_250: All = All(0xfa);
+  pub const OP_RETURN_250: All = All {code: 0xfa};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_251: All = All(0xfb);
+  pub const OP_RETURN_251: All = All {code: 0xfb};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_252: All = All(0xfc);
+  pub const OP_RETURN_252: All = All {code: 0xfc};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_253: All = All(0xfd);
+  pub const OP_RETURN_253: All = All {code: 0xfd};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_254: All = All(0xfe);
+  pub const OP_RETURN_254: All = All {code: 0xfe};
   /// Synonym for OP_RETURN
-  pub const OP_RETURN_255: All = All(0xff);
+  pub const OP_RETURN_255: All = All {code: 0xff};
 }
 
 impl fmt::Debug for All {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     f.write_str("OP_")?;
     match *self {
-      All(x) if x <= 75 => write!(f, "PUSHBYTES_{}", self.0),
+      All {code: x} if x <= 75 => write!(f, "PUSHBYTES_{}", self.code),
       all::OP_PUSHDATA1 => write!(f, "PUSHDATA1"),
       all::OP_PUSHDATA2 => write!(f, "PUSHDATA2"),
       all::OP_PUSHDATA4 => write!(f, "PUSHDATA4"),
       all::OP_PUSHNUM_NEG1 => write!(f, "PUSHNUM_NEG1"),
       all::OP_RESERVED => write!(f, "RESERVED"),
-      All(x) if x >= all::OP_PUSHNUM_1.0 && x <= all::OP_PUSHNUM_16.0 => write!(f, "PUSHNUM_{}", x - all::OP_PUSHNUM_1.0 + 1),
+      All {code: x} if x >= all::OP_PUSHNUM_1.code && x <= all::OP_PUSHNUM_16.code => write!(f, "PUSHNUM_{}", x - all::OP_PUSHNUM_1.code + 1),
       all::OP_NOP => write!(f, "NOP"),
       all::OP_VER => write!(f, "VER"),
       all::OP_IF => write!(f, "IF"),
@@ -648,8 +650,8 @@ impl fmt::Debug for All {
       all::OP_CHECKSIGVERIFY => write!(f, "CHECKSIGVERIFY"),
       all::OP_CHECKMULTISIG => write!(f, "CHECKMULTISIG"),
       all::OP_CHECKMULTISIGVERIFY => write!(f, "CHECKMULTISIGVERIFY"),
-      All(x) if x >= all::OP_NOP1.0 && x <= all::OP_NOP10.0 => write!(f, "NOP{}", x - all::OP_NOP1.0 + 1),
-      All(x) => write!(f, "RETURN_{}", x),
+      All {code: x} if x >= all::OP_NOP1.code && x <= all::OP_NOP10.code => write!(f, "NOP{}", x - all::OP_NOP1.code + 1),
+      All {code: x} => write!(f, "RETURN_{}", x),
     }
   }
 }
@@ -670,24 +672,24 @@ impl All {
         Class::IllegalOp
       // 11 opcodes
       } else if *self == all::OP_NOP ||
-                (all::OP_NOP1.0 <= self.0 &&
-                 self.0 <= all::OP_NOP10.0) {
+                (all::OP_NOP1.code <= self.code &&
+                 self.code <= all::OP_NOP10.code) {
         Class::NoOp
       // 75 opcodes
       } else if *self == all::OP_RESERVED || *self == all::OP_VER || *self == all::OP_RETURN ||
                 *self == all::OP_RESERVED1 || *self == all::OP_RESERVED2 ||
-                self.0 >= all::OP_RETURN_186.0 {
+                self.code >= all::OP_RETURN_186.code {
         Class::ReturnOp
       // 1 opcode
       } else if *self == all::OP_PUSHNUM_NEG1 {
         Class::PushNum(-1)
       // 16 opcodes
-      } else if all::OP_PUSHNUM_1.0 <= self.0 &&
-                self.0 <= all::OP_PUSHNUM_16.0 {
-        Class::PushNum(1 + self.0 as i32 - all::OP_PUSHNUM_1.0 as i32)
+      } else if all::OP_PUSHNUM_1.code <= self.code &&
+                self.code <= all::OP_PUSHNUM_16.code {
+        Class::PushNum(1 + self.code as i32 - all::OP_PUSHNUM_1.code as i32)
       // 76 opcodes
-      } else if self.0 <= all::OP_PUSHBYTES_75.0 {
-        Class::PushBytes(self.0 as u32)
+      } else if self.code <= all::OP_PUSHBYTES_75.code {
+        Class::PushBytes(self.code as u32)
       // 60 opcodes
       } else {
         Class::Ordinary(Ordinary::try_from_all(*self).unwrap())
@@ -697,14 +699,14 @@ impl All {
     /// Encode as a byte
     #[inline]
     pub fn into_u8(&self) -> u8 {
-      self.0
+      self.code
     }
 }
 
 impl From<u8> for All {
     #[inline]
     fn from(b: u8) -> All {
-      All(b)
+      All {code: b}
     }
 }
 
@@ -721,7 +723,7 @@ impl<D: Decoder> Decodable<D> for All {
 impl<S: Encoder> Encodable<S> for All {
     #[inline]
     fn consensus_encode(&self, s: &mut S) -> Result<(), encode::Error> {
-      s.emit_u8(self.0)
+      s.emit_u8(self.code)
     }
 }
 
@@ -779,7 +781,7 @@ macro_rules! ordinary_opcode {
     #[doc(hidden)]
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
     pub enum Ordinary {
-      $( $op = all::$op.0 ),*
+      $( $op = all::$op.code ),*
     }
 
     impl Ordinary {