Metadata-Version: 1.1
Name: ethereum-dasm
Version: 0.1
Summary: An ethereum vm (evm) bytecode disassembler
Home-page: https://github.com/tintinweb/ethereum-dasm
Author: tintinweb
Author-email: tintinweb@oststrom.com
License: GPLv2
Download-URL: https://github.com/tintinweb/ethereum-dasm/tarball/v0.1
Description: # ethereum-dasm 
        ethereum evm bytecode disassembler
        
        [https://github.com/ethereum/] [https://www.ethereum.org/]
        
        **disassembles evm bytecode**
        
        ## usage
        
        * provide the path to the ethereum vm bytecode or the bytecode as an argument to evmdasm. Tries to read from stdin by default.
        * returns !=0 on errors
        * use option `-L` to switch from table to listing mode
        * invalid opcodes are prefixed with `UNKNOWN_`
        * basic jump/xref analysis
        * basicblocking
        * online function signature lookup and operand annotations
        
        ```
        #> evmdasm.py --help
        Usage: evmdasm.py [options]
        
               example: evmdasm.py [-L -F -v] <file_or_bytecode>
                        evmdasm.py [-L -F -v] # read from stdin
                        evmdasm.py [-L -F -a <address>] # fetch contract code from infura.io
        
        
        Options:
          -h, --help            show this help message and exit
          -v VERBOSITY, --verbosity=VERBOSITY
                                available loglevels:
                                critical,fatal,error,warning,warn,info,debug,notset
                                [default: critical]
          -L, --listing         disables table mode, outputs assembly only
          -F, --no-online-lookup
                                disable online function signature lookup
          -a ADDRESS, --address=ADDRESS
                                fetch contract bytecode from address
        
        ```
            #> echo "0x12345678" | python evmdasm.py
            #> python evmdasm.py -v critical "0x12345678"
            #> python evmdasm.py -v critical ether_contract.evm
            #> python evmdasm.py -a <contract address>
        
        
        ## examples
        
        * disasm with basic jumptable analysis (incomplete)
        ```python
        #> python evmdasm.py -f 0x6080604052600436106100ba576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806316243356146100bf57806338af3eed146100ea5780636e15266a14610141578063834ee4171461016c57806386d1a69f146101975780638da5cb5b146101ae5780639b7faaf0146102055780639e1a4d1914610234578063a4e2d6341461025f578063f2fde38b1461028e578063f83d08ba146102d1578063fa2a899714610300575b600080fd5b3480156100cb57600080fd5b506100d461032f565b6040518082815260200191505060405180910390f35b3480156100f657600080fd5b506100ff610335565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561014d57600080fd5b5061015661035b565b6040518082815260200191505060405180910390f35b34801561017857600080fd5b50610181610361565b6040518082815260200191505060405180910390f35b3480156101a357600080fd5b506101ac610367565b005b3480156101ba57600080fd5b506101c36105e6565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561021157600080fd5b5061021a61060b565b604051808215151515815260200191505060405180910390f35b34801561024057600080fd5b5061024961061c565b6040518082815260200191505060405180910390f35b34801561026b57600080fd5b5061027461071b565b604051808215151515815260200191505060405180910390f35b34801561029a57600080fd5b506102cf600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061072e565b005b3480156102dd57600080fd5b506102e6610883565b604051808215151515815260200191505060405180910390f35b34801561030c57600080fd5b50610315610954565b604051808215151515815260200191505060405180910390f35b60045481565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60055481565b60035481565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156103c457600080fd5b600260149054906101000a900460ff1615156103df57600080fd5b600260159054906101000a900460ff161515156103fb57600080fd5b61040361060b565b151561040e57600080fd5b61041661061c565b9050600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b1580156104ff57600080fd5b505af1158015610513573d6000803e3d6000fd5b505050506040513d602081101561052957600080fd5b8101908080519060200190929190505050507f9cf9e3ab58b33f06d81842ea0ad850b6640c6430d6396973312e1715792e7a91600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1682604051808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019250505060405180910390a16001600260156101000a81548160ff02191690831515021790555050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600080429050600454811191505090565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001915050602060405180830381600087803b1580156106db57600080fd5b505af11580156106ef573d6000803e3d6000fd5b505050506040513d602081101561070557600080fd5b8101908080519060200190929190505050905090565b600260149054906101000a900460ff1681565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561078957600080fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141515156107c557600080fd5b8073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156108e057600080fd5b600260149054906101000a900460ff161515156108fc57600080fd5b600061090661061c565b11151561091257600080fd5b4260038190555061093060055460035461096790919063ffffffff16565b6004819055506001600260146101000a81548160ff02191690831515021790555090565b600260159054906101000a900460ff1681565b600080828401905083811015151561097b57fe5b80915050929150505600a165627a7a7230582069642cdfbf8b49cb944b12328add2c81c3557600ed88f94b907c0d547a6251db0029
        
        Inst addr  hex   mnemonic        operand                              xrefs                          description
        ------------------------------------------------------------------------------------------------------------------------------------------------------
           0 [  0 0x000] PUSH1           0x80                                                                # Place 1 byte item on stack.
           1 [  2 0x002] PUSH1           0x40                                                                # Place 1 byte item on stack.
           2 [  4 0x004] MSTORE                                                                              # Save word to memory.
           3 [  5 0x005] PUSH1           0x04                                                                # Place 1 byte item on stack.
           4 [  7 0x007] CALLDATASIZE                                                                        # Get size of input data in current environment.
           5 [  8 0x008] LT                                                                                  # Lesser-than comparison
           6 [  9 0x009] PUSH2           0x00ba                                                              # Place 2-byte item on stack.
           7 [ 12 0x00c] JUMPI           @0xba                                                               # Conditionally alter the program counter.
        
           8 [ 13 0x00d] PUSH1           0x00                                                                # Place 1 byte item on stack.
           9 [ 15 0x00f] CALLDATALOAD                                                                        # Get input data of current environment.
          10 [ 16 0x010] PUSH29          0x0100000000000000000000000000000000000000000000000000000000                                # Place 29-byte item on stack.
          11 [ 46 0x02e] SWAP1                                                                               # Exchange 1st and 2nd stack items.
          12 [ 47 0x02f] DIV                                                                                 # Integer division operation.
          13 [ 48 0x030] PUSH4           0xffffffff                                                          # Place 4-byte item on stack.
          14 [ 53 0x035] AND                                                                                 # Bitwise AND operation.
          15 [ 54 0x036] DUP1                                                                                # Duplicate 1st stack item.
          16 [ 55 0x037] PUSH4           0x16243356                                                          # Place 4-byte item on stack.
          17 [ 60 0x03c] EQ                                                                                  # Equality  comparison
          18 [ 61 0x03d] PUSH2           0x00bf                                                              # Place 2-byte item on stack.
          19 [ 64 0x040] JUMPI           @0xbf                                                               # Conditionally alter the program counter.
        
          20 [ 65 0x041] DUP1                                                                                # Duplicate 1st stack item.
          21 [ 66 0x042] PUSH4           0x38af3eed  ('function beneficiary()')                                # Place 4-byte item on stack.
          22 [ 71 0x047] EQ                                                                                  # Equality  comparison
          23 [ 72 0x048] PUSH2           0x00ea                                                              # Place 2-byte item on stack.
          24 [ 75 0x04b] JUMPI           @0xea                                                               # Conditionally alter the program counter.
        
          25 [ 76 0x04c] DUP1                                                                                # Duplicate 1st stack item.
          26 [ 77 0x04d] PUSH4           0x6e15266a                                                          # Place 4-byte item on stack.
          27 [ 82 0x052] EQ                                                                                  # Equality  comparison
          28 [ 83 0x053] PUSH2           0x0141                                                              # Place 2-byte item on stack.
          29 [ 86 0x056] JUMPI           @0x141                                                              # Conditionally alter the program counter.
        
          30 [ 87 0x057] DUP1                                                                                # Duplicate 1st stack item.
          31 [ 88 0x058] PUSH4           0x834ee417                                                          # Place 4-byte item on stack.
          32 [ 93 0x05d] EQ                                                                                  # Equality  comparison
          33 [ 94 0x05e] PUSH2           0x016c                                                              # Place 2-byte item on stack.
          34 [ 97 0x061] JUMPI           @0x16c                                                              # Conditionally alter the program counter.
        
          35 [ 98 0x062] DUP1                                                                                # Duplicate 1st stack item.
          36 [ 99 0x063] PUSH4           0x86d1a69f  ('function release()')                                  # Place 4-byte item on stack.
          37 [104 0x068] EQ                                                                                  # Equality  comparison
          38 [105 0x069] PUSH2           0x0197                                                              # Place 2-byte item on stack.
          39 [108 0x06c] JUMPI           @0x197                                                              # Conditionally alter the program counter.
        
          40 [109 0x06d] DUP1                                                                                # Duplicate 1st stack item.
          41 [110 0x06e] PUSH4           0x8da5cb5b  (*ambiguous* 'function ideal_warn_timed(uint256,uint128)')                                # Place 4-byte item on stack.
          42 [115 0x073] EQ                                                                                  # Equality  comparison
          43 [116 0x074] PUSH2           0x01ae                                                              # Place 2-byte item on stack.
          44 [119 0x077] JUMPI           @0x1ae                                                              # Conditionally alter the program counter.
        
          45 [120 0x078] DUP1                                                                                # Duplicate 1st stack item.
          46 [121 0x079] PUSH4           0x9b7faaf0  ('function lockOver()')                                 # Place 4-byte item on stack.
          47 [126 0x07e] EQ                                                                                  # Equality  comparison
          48 [127 0x07f] PUSH2           0x0205                                                              # Place 2-byte item on stack.
          49 [130 0x082] JUMPI           @0x205                                                              # Conditionally alter the program counter.
        
          50 [131 0x083] DUP1                                                                                # Duplicate 1st stack item.
          51 [132 0x084] PUSH4           0x9e1a4d19  ('function tokenBalance()')                                # Place 4-byte item on stack.
          52 [137 0x089] EQ                                                                                  # Equality  comparison
          53 [138 0x08a] PUSH2           0x0234                                                              # Place 2-byte item on stack.
          54 [141 0x08d] JUMPI           @0x234                                                              # Conditionally alter the program counter.
        
          55 [142 0x08e] DUP1                                                                                # Duplicate 1st stack item.
          56 [143 0x08f] PUSH4           0xa4e2d634  ('function isLocked()')                                 # Place 4-byte item on stack.
          57 [148 0x094] EQ                                                                                  # Equality  comparison
          58 [149 0x095] PUSH2           0x025f                                                              # Place 2-byte item on stack.
          59 [152 0x098] JUMPI           @0x25f                                                              # Conditionally alter the program counter.
        
          60 [153 0x099] DUP1                                                                                # Duplicate 1st stack item.
          61 [154 0x09a] PUSH4           0xf2fde38b  ('function transferOwnership(address)')                                # Place 4-byte item on stack.
          62 [159 0x09f] EQ                                                                                  # Equality  comparison
          63 [160 0x0a0] PUSH2           0x028e                                                              # Place 2-byte item on stack.
          64 [163 0x0a3] JUMPI           @0x28e                                                              # Conditionally alter the program counter.
        
          65 [164 0x0a4] DUP1                                                                                # Duplicate 1st stack item.
          66 [165 0x0a5] PUSH4           0xf83d08ba  ('function lock()')                                     # Place 4-byte item on stack.
          67 [170 0x0aa] EQ                                                                                  # Equality  comparison
          68 [171 0x0ab] PUSH2           0x02d1                                                              # Place 2-byte item on stack.
          69 [174 0x0ae] JUMPI           @0x2d1                                                              # Conditionally alter the program counter.
        
          70 [175 0x0af] DUP1                                                                                # Duplicate 1st stack item.
          71 [176 0x0b0] PUSH4           0xfa2a8997                                                          # Place 4-byte item on stack.
          72 [181 0x0b5] EQ                                                                                  # Equality  comparison
          73 [182 0x0b6] PUSH2           0x0300                                                              # Place 2-byte item on stack.
          74 [185 0x0b9] JUMPI           @0x300                                                              # Conditionally alter the program counter.
        
        :loc_0xba
          75 [186 0x0ba] JUMPDEST                                             JUMPI@0xc                      # Mark a valid destination for jumps.
          76 [187 0x0bb] PUSH1           0x00                                                                # Place 1 byte item on stack.
          77 [189 0x0bd] DUP1                                                                                # Duplicate 1st stack item.
          78 [190 0x0be] REVERT                                                                              # throw an error
        :loc_0xbf
          79 [191 0x0bf] JUMPDEST                                             JUMPI@0x40                     # Mark a valid destination for jumps.
          80 [192 0x0c0] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
          81 [193 0x0c1] DUP1                                                                                # Duplicate 1st stack item.
          82 [194 0x0c2] ISZERO                                                                              # Simple not operator
          83 [195 0x0c3] PUSH2           0x00cb                                                              # Place 2-byte item on stack.
          84 [198 0x0c6] JUMPI           @0xcb                                                               # Conditionally alter the program counter.
        
          85 [199 0x0c7] PUSH1           0x00                                                                # Place 1 byte item on stack.
          86 [201 0x0c9] DUP1                                                                                # Duplicate 1st stack item.
          87 [202 0x0ca] REVERT                                                                              # throw an error
        :loc_0xcb
          88 [203 0x0cb] JUMPDEST                                             JUMPI@0xc6                     # Mark a valid destination for jumps.
          89 [204 0x0cc] POP                                                                                 # Remove item from stack.
          90 [205 0x0cd] PUSH2           0x00d4                                                              # Place 2-byte item on stack.
          91 [208 0x0d0] PUSH2           0x032f                                                              # Place 2-byte item on stack.
          92 [211 0x0d3] JUMP            @0x32f                                                              # Alter the program counter.
        
        :loc_0xd4
          93 [212 0x0d4] JUMPDEST                                                                            # Mark a valid destination for jumps.
          94 [213 0x0d5] PUSH1           0x40                                                                # Place 1 byte item on stack.
          95 [215 0x0d7] MLOAD                                                                               # Load word from memory.
          96 [216 0x0d8] DUP1                                                                                # Duplicate 1st stack item.
          97 [217 0x0d9] DUP3                                                                                # Duplicate 3rd stack item.
          98 [218 0x0da] DUP2                                                                                # Duplicate 2nd stack item.
          99 [219 0x0db] MSTORE                                                                              # Save word to memory.
         100 [220 0x0dc] PUSH1           0x20                                                                # Place 1 byte item on stack.
         101 [222 0x0de] ADD                                                                                 # Addition operation.
         102 [223 0x0df] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         103 [224 0x0e0] POP                                                                                 # Remove item from stack.
         104 [225 0x0e1] POP                                                                                 # Remove item from stack.
         105 [226 0x0e2] PUSH1           0x40                                                                # Place 1 byte item on stack.
         106 [228 0x0e4] MLOAD                                                                               # Load word from memory.
         107 [229 0x0e5] DUP1                                                                                # Duplicate 1st stack item.
         108 [230 0x0e6] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         109 [231 0x0e7] SUB                                                                                 # Subtraction operation.
         110 [232 0x0e8] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         111 [233 0x0e9] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0xea
         112 [234 0x0ea] JUMPDEST                                             JUMPI@0x4b                     # Mark a valid destination for jumps.
         113 [235 0x0eb] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         114 [236 0x0ec] DUP1                                                                                # Duplicate 1st stack item.
         115 [237 0x0ed] ISZERO                                                                              # Simple not operator
         116 [238 0x0ee] PUSH2           0x00f6                                                              # Place 2-byte item on stack.
         117 [241 0x0f1] JUMPI           @0xf6                                                               # Conditionally alter the program counter.
        
         118 [242 0x0f2] PUSH1           0x00                                                                # Place 1 byte item on stack.
         119 [244 0x0f4] DUP1                                                                                # Duplicate 1st stack item.
         120 [245 0x0f5] REVERT                                                                              # throw an error
        :loc_0xf6
         121 [246 0x0f6] JUMPDEST                                             JUMPI@0xf1                     # Mark a valid destination for jumps.
         122 [247 0x0f7] POP                                                                                 # Remove item from stack.
         123 [248 0x0f8] PUSH2           0x00ff                                                              # Place 2-byte item on stack.
         124 [251 0x0fb] PUSH2           0x0335                                                              # Place 2-byte item on stack.
         125 [254 0x0fe] JUMP            @0x335                                                              # Alter the program counter.
        
        :loc_0xff
         126 [255 0x0ff] JUMPDEST                                                                            # Mark a valid destination for jumps.
         127 [256 0x100] PUSH1           0x40                                                                # Place 1 byte item on stack.
         128 [258 0x102] MLOAD                                                                               # Load word from memory.
         129 [259 0x103] DUP1                                                                                # Duplicate 1st stack item.
         130 [260 0x104] DUP3                                                                                # Duplicate 3rd stack item.
         131 [261 0x105] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         132 [282 0x11a] AND                                                                                 # Bitwise AND operation.
         133 [283 0x11b] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         134 [304 0x130] AND                                                                                 # Bitwise AND operation.
         135 [305 0x131] DUP2                                                                                # Duplicate 2nd stack item.
         136 [306 0x132] MSTORE                                                                              # Save word to memory.
         137 [307 0x133] PUSH1           0x20                                                                # Place 1 byte item on stack.
         138 [309 0x135] ADD                                                                                 # Addition operation.
         139 [310 0x136] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         140 [311 0x137] POP                                                                                 # Remove item from stack.
         141 [312 0x138] POP                                                                                 # Remove item from stack.
         142 [313 0x139] PUSH1           0x40                                                                # Place 1 byte item on stack.
         143 [315 0x13b] MLOAD                                                                               # Load word from memory.
         144 [316 0x13c] DUP1                                                                                # Duplicate 1st stack item.
         145 [317 0x13d] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         146 [318 0x13e] SUB                                                                                 # Subtraction operation.
         147 [319 0x13f] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         148 [320 0x140] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x141
         149 [321 0x141] JUMPDEST                                             JUMPI@0x56                     # Mark a valid destination for jumps.
         150 [322 0x142] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         151 [323 0x143] DUP1                                                                                # Duplicate 1st stack item.
         152 [324 0x144] ISZERO                                                                              # Simple not operator
         153 [325 0x145] PUSH2           0x014d                                                              # Place 2-byte item on stack.
         154 [328 0x148] JUMPI           @0x14d                                                              # Conditionally alter the program counter.
        
         155 [329 0x149] PUSH1           0x00                                                                # Place 1 byte item on stack.
         156 [331 0x14b] DUP1                                                                                # Duplicate 1st stack item.
         157 [332 0x14c] REVERT                                                                              # throw an error
        :loc_0x14d
         158 [333 0x14d] JUMPDEST                                             JUMPI@0x148                    # Mark a valid destination for jumps.
         159 [334 0x14e] POP                                                                                 # Remove item from stack.
         160 [335 0x14f] PUSH2           0x0156                                                              # Place 2-byte item on stack.
         161 [338 0x152] PUSH2           0x035b                                                              # Place 2-byte item on stack.
         162 [341 0x155] JUMP            @0x35b                                                              # Alter the program counter.
        
        :loc_0x156
         163 [342 0x156] JUMPDEST                                                                            # Mark a valid destination for jumps.
         164 [343 0x157] PUSH1           0x40                                                                # Place 1 byte item on stack.
         165 [345 0x159] MLOAD                                                                               # Load word from memory.
         166 [346 0x15a] DUP1                                                                                # Duplicate 1st stack item.
         167 [347 0x15b] DUP3                                                                                # Duplicate 3rd stack item.
         168 [348 0x15c] DUP2                                                                                # Duplicate 2nd stack item.
         169 [349 0x15d] MSTORE                                                                              # Save word to memory.
         170 [350 0x15e] PUSH1           0x20                                                                # Place 1 byte item on stack.
         171 [352 0x160] ADD                                                                                 # Addition operation.
         172 [353 0x161] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         173 [354 0x162] POP                                                                                 # Remove item from stack.
         174 [355 0x163] POP                                                                                 # Remove item from stack.
         175 [356 0x164] PUSH1           0x40                                                                # Place 1 byte item on stack.
         176 [358 0x166] MLOAD                                                                               # Load word from memory.
         177 [359 0x167] DUP1                                                                                # Duplicate 1st stack item.
         178 [360 0x168] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         179 [361 0x169] SUB                                                                                 # Subtraction operation.
         180 [362 0x16a] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         181 [363 0x16b] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x16c
         182 [364 0x16c] JUMPDEST                                             JUMPI@0x61                     # Mark a valid destination for jumps.
         183 [365 0x16d] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         184 [366 0x16e] DUP1                                                                                # Duplicate 1st stack item.
         185 [367 0x16f] ISZERO                                                                              # Simple not operator
         186 [368 0x170] PUSH2           0x0178                                                              # Place 2-byte item on stack.
         187 [371 0x173] JUMPI           @0x178                                                              # Conditionally alter the program counter.
        
         188 [372 0x174] PUSH1           0x00                                                                # Place 1 byte item on stack.
         189 [374 0x176] DUP1                                                                                # Duplicate 1st stack item.
         190 [375 0x177] REVERT                                                                              # throw an error
        :loc_0x178
         191 [376 0x178] JUMPDEST                                             JUMPI@0x173                    # Mark a valid destination for jumps.
         192 [377 0x179] POP                                                                                 # Remove item from stack.
         193 [378 0x17a] PUSH2           0x0181                                                              # Place 2-byte item on stack.
         194 [381 0x17d] PUSH2           0x0361                                                              # Place 2-byte item on stack.
         195 [384 0x180] JUMP            @0x361                                                              # Alter the program counter.
        
        :loc_0x181
         196 [385 0x181] JUMPDEST                                                                            # Mark a valid destination for jumps.
         197 [386 0x182] PUSH1           0x40                                                                # Place 1 byte item on stack.
         198 [388 0x184] MLOAD                                                                               # Load word from memory.
         199 [389 0x185] DUP1                                                                                # Duplicate 1st stack item.
         200 [390 0x186] DUP3                                                                                # Duplicate 3rd stack item.
         201 [391 0x187] DUP2                                                                                # Duplicate 2nd stack item.
         202 [392 0x188] MSTORE                                                                              # Save word to memory.
         203 [393 0x189] PUSH1           0x20                                                                # Place 1 byte item on stack.
         204 [395 0x18b] ADD                                                                                 # Addition operation.
         205 [396 0x18c] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         206 [397 0x18d] POP                                                                                 # Remove item from stack.
         207 [398 0x18e] POP                                                                                 # Remove item from stack.
         208 [399 0x18f] PUSH1           0x40                                                                # Place 1 byte item on stack.
         209 [401 0x191] MLOAD                                                                               # Load word from memory.
         210 [402 0x192] DUP1                                                                                # Duplicate 1st stack item.
         211 [403 0x193] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         212 [404 0x194] SUB                                                                                 # Subtraction operation.
         213 [405 0x195] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         214 [406 0x196] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x197
         215 [407 0x197] JUMPDEST                                             JUMPI@0x6c                     # Mark a valid destination for jumps.
         216 [408 0x198] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         217 [409 0x199] DUP1                                                                                # Duplicate 1st stack item.
         218 [410 0x19a] ISZERO                                                                              # Simple not operator
         219 [411 0x19b] PUSH2           0x01a3                                                              # Place 2-byte item on stack.
         220 [414 0x19e] JUMPI           @0x1a3                                                              # Conditionally alter the program counter.
        
         221 [415 0x19f] PUSH1           0x00                                                                # Place 1 byte item on stack.
         222 [417 0x1a1] DUP1                                                                                # Duplicate 1st stack item.
         223 [418 0x1a2] REVERT                                                                              # throw an error
        :loc_0x1a3
         224 [419 0x1a3] JUMPDEST                                             JUMPI@0x19e                    # Mark a valid destination for jumps.
         225 [420 0x1a4] POP                                                                                 # Remove item from stack.
         226 [421 0x1a5] PUSH2           0x01ac                                                              # Place 2-byte item on stack.
         227 [424 0x1a8] PUSH2           0x0367                                                              # Place 2-byte item on stack.
         228 [427 0x1ab] JUMP            @0x367                                                              # Alter the program counter.
        
        :loc_0x1ac
         229 [428 0x1ac] JUMPDEST                                                                            # Mark a valid destination for jumps.
         230 [429 0x1ad] STOP                                                                                # Halts execution.
        
        :loc_0x1ae
         231 [430 0x1ae] JUMPDEST                                             JUMPI@0x77                     # Mark a valid destination for jumps.
         232 [431 0x1af] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         233 [432 0x1b0] DUP1                                                                                # Duplicate 1st stack item.
         234 [433 0x1b1] ISZERO                                                                              # Simple not operator
         235 [434 0x1b2] PUSH2           0x01ba                                                              # Place 2-byte item on stack.
         236 [437 0x1b5] JUMPI           @0x1ba                                                              # Conditionally alter the program counter.
        
         237 [438 0x1b6] PUSH1           0x00                                                                # Place 1 byte item on stack.
         238 [440 0x1b8] DUP1                                                                                # Duplicate 1st stack item.
         239 [441 0x1b9] REVERT                                                                              # throw an error
        :loc_0x1ba
         240 [442 0x1ba] JUMPDEST                                             JUMPI@0x1b5                    # Mark a valid destination for jumps.
         241 [443 0x1bb] POP                                                                                 # Remove item from stack.
         242 [444 0x1bc] PUSH2           0x01c3                                                              # Place 2-byte item on stack.
         243 [447 0x1bf] PUSH2           0x05e6                                                              # Place 2-byte item on stack.
         244 [450 0x1c2] JUMP            @0x5e6                                                              # Alter the program counter.
        
        :loc_0x1c3
         245 [451 0x1c3] JUMPDEST                                                                            # Mark a valid destination for jumps.
         246 [452 0x1c4] PUSH1           0x40                                                                # Place 1 byte item on stack.
         247 [454 0x1c6] MLOAD                                                                               # Load word from memory.
         248 [455 0x1c7] DUP1                                                                                # Duplicate 1st stack item.
         249 [456 0x1c8] DUP3                                                                                # Duplicate 3rd stack item.
         250 [457 0x1c9] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         251 [478 0x1de] AND                                                                                 # Bitwise AND operation.
         252 [479 0x1df] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         253 [500 0x1f4] AND                                                                                 # Bitwise AND operation.
         254 [501 0x1f5] DUP2                                                                                # Duplicate 2nd stack item.
         255 [502 0x1f6] MSTORE                                                                              # Save word to memory.
         256 [503 0x1f7] PUSH1           0x20                                                                # Place 1 byte item on stack.
         257 [505 0x1f9] ADD                                                                                 # Addition operation.
         258 [506 0x1fa] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         259 [507 0x1fb] POP                                                                                 # Remove item from stack.
         260 [508 0x1fc] POP                                                                                 # Remove item from stack.
         261 [509 0x1fd] PUSH1           0x40                                                                # Place 1 byte item on stack.
         262 [511 0x1ff] MLOAD                                                                               # Load word from memory.
         263 [512 0x200] DUP1                                                                                # Duplicate 1st stack item.
         264 [513 0x201] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         265 [514 0x202] SUB                                                                                 # Subtraction operation.
         266 [515 0x203] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         267 [516 0x204] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x205
         268 [517 0x205] JUMPDEST                                             JUMPI@0x82                     # Mark a valid destination for jumps.
         269 [518 0x206] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         270 [519 0x207] DUP1                                                                                # Duplicate 1st stack item.
         271 [520 0x208] ISZERO                                                                              # Simple not operator
         272 [521 0x209] PUSH2           0x0211                                                              # Place 2-byte item on stack.
         273 [524 0x20c] JUMPI           @0x211                                                              # Conditionally alter the program counter.
        
         274 [525 0x20d] PUSH1           0x00                                                                # Place 1 byte item on stack.
         275 [527 0x20f] DUP1                                                                                # Duplicate 1st stack item.
         276 [528 0x210] REVERT                                                                              # throw an error
        :loc_0x211
         277 [529 0x211] JUMPDEST                                             JUMPI@0x20c                    # Mark a valid destination for jumps.
         278 [530 0x212] POP                                                                                 # Remove item from stack.
         279 [531 0x213] PUSH2           0x021a                                                              # Place 2-byte item on stack.
         280 [534 0x216] PUSH2           0x060b                                                              # Place 2-byte item on stack.
         281 [537 0x219] JUMP            @0x60b                                                              # Alter the program counter.
        
        :loc_0x21a
         282 [538 0x21a] JUMPDEST                                                                            # Mark a valid destination for jumps.
         283 [539 0x21b] PUSH1           0x40                                                                # Place 1 byte item on stack.
         284 [541 0x21d] MLOAD                                                                               # Load word from memory.
         285 [542 0x21e] DUP1                                                                                # Duplicate 1st stack item.
         286 [543 0x21f] DUP3                                                                                # Duplicate 3rd stack item.
         287 [544 0x220] ISZERO                                                                              # Simple not operator
         288 [545 0x221] ISZERO                                                                              # Simple not operator
         289 [546 0x222] ISZERO                                                                              # Simple not operator
         290 [547 0x223] ISZERO                                                                              # Simple not operator
         291 [548 0x224] DUP2                                                                                # Duplicate 2nd stack item.
         292 [549 0x225] MSTORE                                                                              # Save word to memory.
         293 [550 0x226] PUSH1           0x20                                                                # Place 1 byte item on stack.
         294 [552 0x228] ADD                                                                                 # Addition operation.
         295 [553 0x229] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         296 [554 0x22a] POP                                                                                 # Remove item from stack.
         297 [555 0x22b] POP                                                                                 # Remove item from stack.
         298 [556 0x22c] PUSH1           0x40                                                                # Place 1 byte item on stack.
         299 [558 0x22e] MLOAD                                                                               # Load word from memory.
         300 [559 0x22f] DUP1                                                                                # Duplicate 1st stack item.
         301 [560 0x230] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         302 [561 0x231] SUB                                                                                 # Subtraction operation.
         303 [562 0x232] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         304 [563 0x233] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x234
         305 [564 0x234] JUMPDEST                                             JUMPI@0x8d                     # Mark a valid destination for jumps.
         306 [565 0x235] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         307 [566 0x236] DUP1                                                                                # Duplicate 1st stack item.
         308 [567 0x237] ISZERO                                                                              # Simple not operator
         309 [568 0x238] PUSH2           0x0240                                                              # Place 2-byte item on stack.
         310 [571 0x23b] JUMPI           @0x240                                                              # Conditionally alter the program counter.
        
         311 [572 0x23c] PUSH1           0x00                                                                # Place 1 byte item on stack.
         312 [574 0x23e] DUP1                                                                                # Duplicate 1st stack item.
         313 [575 0x23f] REVERT                                                                              # throw an error
        :loc_0x240
         314 [576 0x240] JUMPDEST                                             JUMPI@0x23b                    # Mark a valid destination for jumps.
         315 [577 0x241] POP                                                                                 # Remove item from stack.
         316 [578 0x242] PUSH2           0x0249                                                              # Place 2-byte item on stack.
         317 [581 0x245] PUSH2           0x061c                                                              # Place 2-byte item on stack.
         318 [584 0x248] JUMP            @0x61c                                                              # Alter the program counter.
        
        :loc_0x249
         319 [585 0x249] JUMPDEST                                                                            # Mark a valid destination for jumps.
         320 [586 0x24a] PUSH1           0x40                                                                # Place 1 byte item on stack.
         321 [588 0x24c] MLOAD                                                                               # Load word from memory.
         322 [589 0x24d] DUP1                                                                                # Duplicate 1st stack item.
         323 [590 0x24e] DUP3                                                                                # Duplicate 3rd stack item.
         324 [591 0x24f] DUP2                                                                                # Duplicate 2nd stack item.
         325 [592 0x250] MSTORE                                                                              # Save word to memory.
         326 [593 0x251] PUSH1           0x20                                                                # Place 1 byte item on stack.
         327 [595 0x253] ADD                                                                                 # Addition operation.
         328 [596 0x254] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         329 [597 0x255] POP                                                                                 # Remove item from stack.
         330 [598 0x256] POP                                                                                 # Remove item from stack.
         331 [599 0x257] PUSH1           0x40                                                                # Place 1 byte item on stack.
         332 [601 0x259] MLOAD                                                                               # Load word from memory.
         333 [602 0x25a] DUP1                                                                                # Duplicate 1st stack item.
         334 [603 0x25b] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         335 [604 0x25c] SUB                                                                                 # Subtraction operation.
         336 [605 0x25d] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         337 [606 0x25e] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x25f
         338 [607 0x25f] JUMPDEST                                             JUMPI@0x98                     # Mark a valid destination for jumps.
         339 [608 0x260] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         340 [609 0x261] DUP1                                                                                # Duplicate 1st stack item.
         341 [610 0x262] ISZERO                                                                              # Simple not operator
         342 [611 0x263] PUSH2           0x026b                                                              # Place 2-byte item on stack.
         343 [614 0x266] JUMPI           @0x26b                                                              # Conditionally alter the program counter.
        
         344 [615 0x267] PUSH1           0x00                                                                # Place 1 byte item on stack.
         345 [617 0x269] DUP1                                                                                # Duplicate 1st stack item.
         346 [618 0x26a] REVERT                                                                              # throw an error
        :loc_0x26b
         347 [619 0x26b] JUMPDEST                                             JUMPI@0x266                    # Mark a valid destination for jumps.
         348 [620 0x26c] POP                                                                                 # Remove item from stack.
         349 [621 0x26d] PUSH2           0x0274                                                              # Place 2-byte item on stack.
         350 [624 0x270] PUSH2           0x071b                                                              # Place 2-byte item on stack.
         351 [627 0x273] JUMP            @0x71b                                                              # Alter the program counter.
        
        :loc_0x274
         352 [628 0x274] JUMPDEST                                                                            # Mark a valid destination for jumps.
         353 [629 0x275] PUSH1           0x40                                                                # Place 1 byte item on stack.
         354 [631 0x277] MLOAD                                                                               # Load word from memory.
         355 [632 0x278] DUP1                                                                                # Duplicate 1st stack item.
         356 [633 0x279] DUP3                                                                                # Duplicate 3rd stack item.
         357 [634 0x27a] ISZERO                                                                              # Simple not operator
         358 [635 0x27b] ISZERO                                                                              # Simple not operator
         359 [636 0x27c] ISZERO                                                                              # Simple not operator
         360 [637 0x27d] ISZERO                                                                              # Simple not operator
         361 [638 0x27e] DUP2                                                                                # Duplicate 2nd stack item.
         362 [639 0x27f] MSTORE                                                                              # Save word to memory.
         363 [640 0x280] PUSH1           0x20                                                                # Place 1 byte item on stack.
         364 [642 0x282] ADD                                                                                 # Addition operation.
         365 [643 0x283] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         366 [644 0x284] POP                                                                                 # Remove item from stack.
         367 [645 0x285] POP                                                                                 # Remove item from stack.
         368 [646 0x286] PUSH1           0x40                                                                # Place 1 byte item on stack.
         369 [648 0x288] MLOAD                                                                               # Load word from memory.
         370 [649 0x289] DUP1                                                                                # Duplicate 1st stack item.
         371 [650 0x28a] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         372 [651 0x28b] SUB                                                                                 # Subtraction operation.
         373 [652 0x28c] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         374 [653 0x28d] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x28e
         375 [654 0x28e] JUMPDEST                                             JUMPI@0xa3                     # Mark a valid destination for jumps.
         376 [655 0x28f] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         377 [656 0x290] DUP1                                                                                # Duplicate 1st stack item.
         378 [657 0x291] ISZERO                                                                              # Simple not operator
         379 [658 0x292] PUSH2           0x029a                                                              # Place 2-byte item on stack.
         380 [661 0x295] JUMPI           @0x29a                                                              # Conditionally alter the program counter.
        
         381 [662 0x296] PUSH1           0x00                                                                # Place 1 byte item on stack.
         382 [664 0x298] DUP1                                                                                # Duplicate 1st stack item.
         383 [665 0x299] REVERT                                                                              # throw an error
        :loc_0x29a
         384 [666 0x29a] JUMPDEST                                             JUMPI@0x295                    # Mark a valid destination for jumps.
         385 [667 0x29b] POP                                                                                 # Remove item from stack.
         386 [668 0x29c] PUSH2           0x02cf                                                              # Place 2-byte item on stack.
         387 [671 0x29f] PUSH1           0x04                                                                # Place 1 byte item on stack.
         388 [673 0x2a1] DUP1                                                                                # Duplicate 1st stack item.
         389 [674 0x2a2] CALLDATASIZE                                                                        # Get size of input data in current environment.
         390 [675 0x2a3] SUB                                                                                 # Subtraction operation.
         391 [676 0x2a4] DUP2                                                                                # Duplicate 2nd stack item.
         392 [677 0x2a5] ADD                                                                                 # Addition operation.
         393 [678 0x2a6] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         394 [679 0x2a7] DUP1                                                                                # Duplicate 1st stack item.
         395 [680 0x2a8] DUP1                                                                                # Duplicate 1st stack item.
         396 [681 0x2a9] CALLDATALOAD                                                                        # Get input data of current environment.
         397 [682 0x2aa] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         398 [703 0x2bf] AND                                                                                 # Bitwise AND operation.
         399 [704 0x2c0] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         400 [705 0x2c1] PUSH1           0x20                                                                # Place 1 byte item on stack.
         401 [707 0x2c3] ADD                                                                                 # Addition operation.
         402 [708 0x2c4] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         403 [709 0x2c5] SWAP3                                                                               # Exchange 1st and 4th stack items.
         404 [710 0x2c6] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         405 [711 0x2c7] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         406 [712 0x2c8] POP                                                                                 # Remove item from stack.
         407 [713 0x2c9] POP                                                                                 # Remove item from stack.
         408 [714 0x2ca] POP                                                                                 # Remove item from stack.
         409 [715 0x2cb] PUSH2           0x072e                                                              # Place 2-byte item on stack.
         410 [718 0x2ce] JUMP            @0x72e                                                              # Alter the program counter.
        
        :loc_0x2cf
         411 [719 0x2cf] JUMPDEST                                                                            # Mark a valid destination for jumps.
         412 [720 0x2d0] STOP                                                                                # Halts execution.
        
        :loc_0x2d1
         413 [721 0x2d1] JUMPDEST                                             JUMPI@0xae                     # Mark a valid destination for jumps.
         414 [722 0x2d2] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         415 [723 0x2d3] DUP1                                                                                # Duplicate 1st stack item.
         416 [724 0x2d4] ISZERO                                                                              # Simple not operator
         417 [725 0x2d5] PUSH2           0x02dd                                                              # Place 2-byte item on stack.
         418 [728 0x2d8] JUMPI           @0x2dd                                                              # Conditionally alter the program counter.
        
         419 [729 0x2d9] PUSH1           0x00                                                                # Place 1 byte item on stack.
         420 [731 0x2db] DUP1                                                                                # Duplicate 1st stack item.
         421 [732 0x2dc] REVERT                                                                              # throw an error
        :loc_0x2dd
         422 [733 0x2dd] JUMPDEST                                             JUMPI@0x2d8                    # Mark a valid destination for jumps.
         423 [734 0x2de] POP                                                                                 # Remove item from stack.
         424 [735 0x2df] PUSH2           0x02e6                                                              # Place 2-byte item on stack.
         425 [738 0x2e2] PUSH2           0x0883                                                              # Place 2-byte item on stack.
         426 [741 0x2e5] JUMP            @0x883                                                              # Alter the program counter.
        
        :loc_0x2e6
         427 [742 0x2e6] JUMPDEST                                                                            # Mark a valid destination for jumps.
         428 [743 0x2e7] PUSH1           0x40                                                                # Place 1 byte item on stack.
         429 [745 0x2e9] MLOAD                                                                               # Load word from memory.
         430 [746 0x2ea] DUP1                                                                                # Duplicate 1st stack item.
         431 [747 0x2eb] DUP3                                                                                # Duplicate 3rd stack item.
         432 [748 0x2ec] ISZERO                                                                              # Simple not operator
         433 [749 0x2ed] ISZERO                                                                              # Simple not operator
         434 [750 0x2ee] ISZERO                                                                              # Simple not operator
         435 [751 0x2ef] ISZERO                                                                              # Simple not operator
         436 [752 0x2f0] DUP2                                                                                # Duplicate 2nd stack item.
         437 [753 0x2f1] MSTORE                                                                              # Save word to memory.
         438 [754 0x2f2] PUSH1           0x20                                                                # Place 1 byte item on stack.
         439 [756 0x2f4] ADD                                                                                 # Addition operation.
         440 [757 0x2f5] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         441 [758 0x2f6] POP                                                                                 # Remove item from stack.
         442 [759 0x2f7] POP                                                                                 # Remove item from stack.
         443 [760 0x2f8] PUSH1           0x40                                                                # Place 1 byte item on stack.
         444 [762 0x2fa] MLOAD                                                                               # Load word from memory.
         445 [763 0x2fb] DUP1                                                                                # Duplicate 1st stack item.
         446 [764 0x2fc] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         447 [765 0x2fd] SUB                                                                                 # Subtraction operation.
         448 [766 0x2fe] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         449 [767 0x2ff] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x300
         450 [768 0x300] JUMPDEST                                             JUMPI@0xb9                     # Mark a valid destination for jumps.
         451 [769 0x301] CALLVALUE                                                                           # Get deposited value by the instruction/transaction responsible for this execution.
         452 [770 0x302] DUP1                                                                                # Duplicate 1st stack item.
         453 [771 0x303] ISZERO                                                                              # Simple not operator
         454 [772 0x304] PUSH2           0x030c                                                              # Place 2-byte item on stack.
         455 [775 0x307] JUMPI           @0x30c                                                              # Conditionally alter the program counter.
        
         456 [776 0x308] PUSH1           0x00                                                                # Place 1 byte item on stack.
         457 [778 0x30a] DUP1                                                                                # Duplicate 1st stack item.
         458 [779 0x30b] REVERT                                                                              # throw an error
        :loc_0x30c
         459 [780 0x30c] JUMPDEST                                             JUMPI@0x307                    # Mark a valid destination for jumps.
         460 [781 0x30d] POP                                                                                 # Remove item from stack.
         461 [782 0x30e] PUSH2           0x0315                                                              # Place 2-byte item on stack.
         462 [785 0x311] PUSH2           0x0954                                                              # Place 2-byte item on stack.
         463 [788 0x314] JUMP            @0x954                                                              # Alter the program counter.
        
        :loc_0x315
         464 [789 0x315] JUMPDEST                                                                            # Mark a valid destination for jumps.
         465 [790 0x316] PUSH1           0x40                                                                # Place 1 byte item on stack.
         466 [792 0x318] MLOAD                                                                               # Load word from memory.
         467 [793 0x319] DUP1                                                                                # Duplicate 1st stack item.
         468 [794 0x31a] DUP3                                                                                # Duplicate 3rd stack item.
         469 [795 0x31b] ISZERO                                                                              # Simple not operator
         470 [796 0x31c] ISZERO                                                                              # Simple not operator
         471 [797 0x31d] ISZERO                                                                              # Simple not operator
         472 [798 0x31e] ISZERO                                                                              # Simple not operator
         473 [799 0x31f] DUP2                                                                                # Duplicate 2nd stack item.
         474 [800 0x320] MSTORE                                                                              # Save word to memory.
         475 [801 0x321] PUSH1           0x20                                                                # Place 1 byte item on stack.
         476 [803 0x323] ADD                                                                                 # Addition operation.
         477 [804 0x324] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         478 [805 0x325] POP                                                                                 # Remove item from stack.
         479 [806 0x326] POP                                                                                 # Remove item from stack.
         480 [807 0x327] PUSH1           0x40                                                                # Place 1 byte item on stack.
         481 [809 0x329] MLOAD                                                                               # Load word from memory.
         482 [810 0x32a] DUP1                                                                                # Duplicate 1st stack item.
         483 [811 0x32b] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         484 [812 0x32c] SUB                                                                                 # Subtraction operation.
         485 [813 0x32d] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         486 [814 0x32e] RETURN                                                                              # Halt execution returning output data.
        
        :loc_0x32f
         487 [815 0x32f] JUMPDEST                                             JUMP@0xd3                      # Mark a valid destination for jumps.
         488 [816 0x330] PUSH1           0x04                                                                # Place 1 byte item on stack.
         489 [818 0x332] SLOAD                                                                               # Load word from storage.
         490 [819 0x333] DUP2                                                                                # Duplicate 2nd stack item.
         491 [820 0x334] JUMP                                                                                # Alter the program counter.
        
        :loc_0x335
         492 [821 0x335] JUMPDEST                                             JUMP@0xfe                      # Mark a valid destination for jumps.
         493 [822 0x336] PUSH1           0x02                                                                # Place 1 byte item on stack.
         494 [824 0x338] PUSH1           0x00                                                                # Place 1 byte item on stack.
         495 [826 0x33a] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         496 [827 0x33b] SLOAD                                                                               # Load word from storage.
         497 [828 0x33c] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         498 [829 0x33d] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         499 [832 0x340] EXP                                                                                 # Exponential operation.
         500 [833 0x341] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         501 [834 0x342] DIV                                                                                 # Integer division operation.
         502 [835 0x343] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         503 [856 0x358] AND                                                                                 # Bitwise AND operation.
         504 [857 0x359] DUP2                                                                                # Duplicate 2nd stack item.
         505 [858 0x35a] JUMP                                                                                # Alter the program counter.
        
        :loc_0x35b
         506 [859 0x35b] JUMPDEST                                             JUMP@0x155                     # Mark a valid destination for jumps.
         507 [860 0x35c] PUSH1           0x05                                                                # Place 1 byte item on stack.
         508 [862 0x35e] SLOAD                                                                               # Load word from storage.
         509 [863 0x35f] DUP2                                                                                # Duplicate 2nd stack item.
         510 [864 0x360] JUMP                                                                                # Alter the program counter.
        
        :loc_0x361
         511 [865 0x361] JUMPDEST                                             JUMP@0x180                     # Mark a valid destination for jumps.
         512 [866 0x362] PUSH1           0x03                                                                # Place 1 byte item on stack.
         513 [868 0x364] SLOAD                                                                               # Load word from storage.
         514 [869 0x365] DUP2                                                                                # Duplicate 2nd stack item.
         515 [870 0x366] JUMP                                                                                # Alter the program counter.
        
        :loc_0x367
         516 [871 0x367] JUMPDEST                                             JUMP@0x1ab                     # Mark a valid destination for jumps.
         517 [872 0x368] PUSH1           0x00                                                                # Place 1 byte item on stack.
         518 [874 0x36a] DUP1                                                                                # Duplicate 1st stack item.
         519 [875 0x36b] PUSH1           0x00                                                                # Place 1 byte item on stack.
         520 [877 0x36d] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         521 [878 0x36e] SLOAD                                                                               # Load word from storage.
         522 [879 0x36f] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         523 [880 0x370] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         524 [883 0x373] EXP                                                                                 # Exponential operation.
         525 [884 0x374] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         526 [885 0x375] DIV                                                                                 # Integer division operation.
         527 [886 0x376] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         528 [907 0x38b] AND                                                                                 # Bitwise AND operation.
         529 [908 0x38c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         530 [929 0x3a1] AND                                                                                 # Bitwise AND operation.
         531 [930 0x3a2] CALLER                                                                              # Get caller address.This is the address of the account that is directly responsible for this execution.
         532 [931 0x3a3] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         533 [952 0x3b8] AND                                                                                 # Bitwise AND operation.
         534 [953 0x3b9] EQ                                                                                  # Equality  comparison
         535 [954 0x3ba] ISZERO                                                                              # Simple not operator
         536 [955 0x3bb] ISZERO                                                                              # Simple not operator
         537 [956 0x3bc] PUSH2           0x03c4                                                              # Place 2-byte item on stack.
         538 [959 0x3bf] JUMPI           @0x3c4                                                              # Conditionally alter the program counter.
        
         539 [960 0x3c0] PUSH1           0x00                                                                # Place 1 byte item on stack.
         540 [962 0x3c2] DUP1                                                                                # Duplicate 1st stack item.
         541 [963 0x3c3] REVERT                                                                              # throw an error
        :loc_0x3c4
         542 [964 0x3c4] JUMPDEST                                             JUMPI@0x3bf                    # Mark a valid destination for jumps.
         543 [965 0x3c5] PUSH1           0x02                                                                # Place 1 byte item on stack.
         544 [967 0x3c7] PUSH1           0x14                                                                # Place 1 byte item on stack.
         545 [969 0x3c9] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         546 [970 0x3ca] SLOAD                                                                               # Load word from storage.
         547 [971 0x3cb] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         548 [972 0x3cc] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         549 [975 0x3cf] EXP                                                                                 # Exponential operation.
         550 [976 0x3d0] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         551 [977 0x3d1] DIV                                                                                 # Integer division operation.
         552 [978 0x3d2] PUSH1           0xff                                                                # Place 1 byte item on stack.
         553 [980 0x3d4] AND                                                                                 # Bitwise AND operation.
         554 [981 0x3d5] ISZERO                                                                              # Simple not operator
         555 [982 0x3d6] ISZERO                                                                              # Simple not operator
         556 [983 0x3d7] PUSH2           0x03df                                                              # Place 2-byte item on stack.
         557 [986 0x3da] JUMPI           @0x3df                                                              # Conditionally alter the program counter.
        
         558 [987 0x3db] PUSH1           0x00                                                                # Place 1 byte item on stack.
         559 [989 0x3dd] DUP1                                                                                # Duplicate 1st stack item.
         560 [990 0x3de] REVERT                                                                              # throw an error
        :loc_0x3df
         561 [991 0x3df] JUMPDEST                                             JUMPI@0x3da                    # Mark a valid destination for jumps.
         562 [992 0x3e0] PUSH1           0x02                                                                # Place 1 byte item on stack.
         563 [994 0x3e2] PUSH1           0x15                                                                # Place 1 byte item on stack.
         564 [996 0x3e4] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         565 [997 0x3e5] SLOAD                                                                               # Load word from storage.
         566 [998 0x3e6] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         567 [999 0x3e7] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         568 [1002 0x3ea] EXP                                                                                 # Exponential operation.
         569 [1003 0x3eb] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         570 [1004 0x3ec] DIV                                                                                 # Integer division operation.
         571 [1005 0x3ed] PUSH1           0xff                                                                # Place 1 byte item on stack.
         572 [1007 0x3ef] AND                                                                                 # Bitwise AND operation.
         573 [1008 0x3f0] ISZERO                                                                              # Simple not operator
         574 [1009 0x3f1] ISZERO                                                                              # Simple not operator
         575 [1010 0x3f2] ISZERO                                                                              # Simple not operator
         576 [1011 0x3f3] PUSH2           0x03fb                                                              # Place 2-byte item on stack.
         577 [1014 0x3f6] JUMPI           @0x3fb                                                              # Conditionally alter the program counter.
        
         578 [1015 0x3f7] PUSH1           0x00                                                                # Place 1 byte item on stack.
         579 [1017 0x3f9] DUP1                                                                                # Duplicate 1st stack item.
         580 [1018 0x3fa] REVERT                                                                              # throw an error
        :loc_0x3fb
         581 [1019 0x3fb] JUMPDEST                                             JUMPI@0x3f6                    # Mark a valid destination for jumps.
         582 [1020 0x3fc] PUSH2           0x0403                                                              # Place 2-byte item on stack.
         583 [1023 0x3ff] PUSH2           0x060b                                                              # Place 2-byte item on stack.
         584 [1026 0x402] JUMP            @0x60b                                                              # Alter the program counter.
        
        :loc_0x403
         585 [1027 0x403] JUMPDEST                                                                            # Mark a valid destination for jumps.
         586 [1028 0x404] ISZERO                                                                              # Simple not operator
         587 [1029 0x405] ISZERO                                                                              # Simple not operator
         588 [1030 0x406] PUSH2           0x040e                                                              # Place 2-byte item on stack.
         589 [1033 0x409] JUMPI           @0x40e                                                              # Conditionally alter the program counter.
        
         590 [1034 0x40a] PUSH1           0x00                                                                # Place 1 byte item on stack.
         591 [1036 0x40c] DUP1                                                                                # Duplicate 1st stack item.
         592 [1037 0x40d] REVERT                                                                              # throw an error
        :loc_0x40e
         593 [1038 0x40e] JUMPDEST                                             JUMPI@0x409                    # Mark a valid destination for jumps.
         594 [1039 0x40f] PUSH2           0x0416                                                              # Place 2-byte item on stack.
         595 [1042 0x412] PUSH2           0x061c                                                              # Place 2-byte item on stack.
         596 [1045 0x415] JUMP            @0x61c                                                              # Alter the program counter.
        
        :loc_0x416
         597 [1046 0x416] JUMPDEST                                                                            # Mark a valid destination for jumps.
         598 [1047 0x417] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         599 [1048 0x418] POP                                                                                 # Remove item from stack.
         600 [1049 0x419] PUSH1           0x01                                                                # Place 1 byte item on stack.
         601 [1051 0x41b] PUSH1           0x00                                                                # Place 1 byte item on stack.
         602 [1053 0x41d] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         603 [1054 0x41e] SLOAD                                                                               # Load word from storage.
         604 [1055 0x41f] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         605 [1056 0x420] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         606 [1059 0x423] EXP                                                                                 # Exponential operation.
         607 [1060 0x424] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         608 [1061 0x425] DIV                                                                                 # Integer division operation.
         609 [1062 0x426] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         610 [1083 0x43b] AND                                                                                 # Bitwise AND operation.
         611 [1084 0x43c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         612 [1105 0x451] AND                                                                                 # Bitwise AND operation.
         613 [1106 0x452] PUSH4           0xa9059cbb  (*ambiguous* 'function many_msg_babbage(bytes1)')                                # Place 4-byte item on stack.
         614 [1111 0x457] PUSH1           0x02                                                                # Place 1 byte item on stack.
         615 [1113 0x459] PUSH1           0x00                                                                # Place 1 byte item on stack.
         616 [1115 0x45b] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         617 [1116 0x45c] SLOAD                                                                               # Load word from storage.
         618 [1117 0x45d] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         619 [1118 0x45e] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         620 [1121 0x461] EXP                                                                                 # Exponential operation.
         621 [1122 0x462] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         622 [1123 0x463] DIV                                                                                 # Integer division operation.
         623 [1124 0x464] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         624 [1145 0x479] AND                                                                                 # Bitwise AND operation.
         625 [1146 0x47a] DUP4                                                                                # Duplicate 4th stack item.
         626 [1147 0x47b] PUSH1           0x40                                                                # Place 1 byte item on stack.
         627 [1149 0x47d] MLOAD                                                                               # Load word from memory.
         628 [1150 0x47e] DUP4                                                                                # Duplicate 4th stack item.
         629 [1151 0x47f] PUSH4           0xffffffff                                                          # Place 4-byte item on stack.
         630 [1156 0x484] AND                                                                                 # Bitwise AND operation.
         631 [1157 0x485] PUSH29          0x0100000000000000000000000000000000000000000000000000000000                                # Place 29-byte item on stack.
         632 [1187 0x4a3] MUL                                                                                 # Multiplication operation.
         633 [1188 0x4a4] DUP2                                                                                # Duplicate 2nd stack item.
         634 [1189 0x4a5] MSTORE                                                                              # Save word to memory.
         635 [1190 0x4a6] PUSH1           0x04                                                                # Place 1 byte item on stack.
         636 [1192 0x4a8] ADD                                                                                 # Addition operation.
         637 [1193 0x4a9] DUP1                                                                                # Duplicate 1st stack item.
         638 [1194 0x4aa] DUP4                                                                                # Duplicate 4th stack item.
         639 [1195 0x4ab] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         640 [1216 0x4c0] AND                                                                                 # Bitwise AND operation.
         641 [1217 0x4c1] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         642 [1238 0x4d6] AND                                                                                 # Bitwise AND operation.
         643 [1239 0x4d7] DUP2                                                                                # Duplicate 2nd stack item.
         644 [1240 0x4d8] MSTORE                                                                              # Save word to memory.
         645 [1241 0x4d9] PUSH1           0x20                                                                # Place 1 byte item on stack.
         646 [1243 0x4db] ADD                                                                                 # Addition operation.
         647 [1244 0x4dc] DUP3                                                                                # Duplicate 3rd stack item.
         648 [1245 0x4dd] DUP2                                                                                # Duplicate 2nd stack item.
         649 [1246 0x4de] MSTORE                                                                              # Save word to memory.
         650 [1247 0x4df] PUSH1           0x20                                                                # Place 1 byte item on stack.
         651 [1249 0x4e1] ADD                                                                                 # Addition operation.
         652 [1250 0x4e2] SWAP3                                                                               # Exchange 1st and 4th stack items.
         653 [1251 0x4e3] POP                                                                                 # Remove item from stack.
         654 [1252 0x4e4] POP                                                                                 # Remove item from stack.
         655 [1253 0x4e5] POP                                                                                 # Remove item from stack.
         656 [1254 0x4e6] PUSH1           0x20                                                                # Place 1 byte item on stack.
         657 [1256 0x4e8] PUSH1           0x40                                                                # Place 1 byte item on stack.
         658 [1258 0x4ea] MLOAD                                                                               # Load word from memory.
         659 [1259 0x4eb] DUP1                                                                                # Duplicate 1st stack item.
         660 [1260 0x4ec] DUP4                                                                                # Duplicate 4th stack item.
         661 [1261 0x4ed] SUB                                                                                 # Subtraction operation.
         662 [1262 0x4ee] DUP2                                                                                # Duplicate 2nd stack item.
         663 [1263 0x4ef] PUSH1           0x00                                                                # Place 1 byte item on stack.
         664 [1265 0x4f1] DUP8                                                                                # Duplicate 8th stack item.
         665 [1266 0x4f2] DUP1                                                                                # Duplicate 1st stack item.
         666 [1267 0x4f3] EXTCODESIZE                                                                         # Get size of an account’s code.
         667 [1268 0x4f4] ISZERO                                                                              # Simple not operator
         668 [1269 0x4f5] DUP1                                                                                # Duplicate 1st stack item.
         669 [1270 0x4f6] ISZERO                                                                              # Simple not operator
         670 [1271 0x4f7] PUSH2           0x04ff                                                              # Place 2-byte item on stack.
         671 [1274 0x4fa] JUMPI           @0x4ff                                                              # Conditionally alter the program counter.
        
         672 [1275 0x4fb] PUSH1           0x00                                                                # Place 1 byte item on stack.
         673 [1277 0x4fd] DUP1                                                                                # Duplicate 1st stack item.
         674 [1278 0x4fe] REVERT                                                                              # throw an error
        :loc_0x4ff
         675 [1279 0x4ff] JUMPDEST                                             JUMPI@0x4fa                    # Mark a valid destination for jumps.
         676 [1280 0x500] POP                                                                                 # Remove item from stack.
         677 [1281 0x501] GAS                                                                                 # Get the amount of available gas, including the corresponding reduction
         678 [1282 0x502] CALL                                                                                # Message-call into an account.
         679 [1283 0x503] ISZERO                                                                              # Simple not operator
         680 [1284 0x504] DUP1                                                                                # Duplicate 1st stack item.
         681 [1285 0x505] ISZERO                                                                              # Simple not operator
         682 [1286 0x506] PUSH2           0x0513                                                              # Place 2-byte item on stack.
         683 [1289 0x509] JUMPI           @0x513                                                              # Conditionally alter the program counter.
        
         684 [1290 0x50a] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         685 [1291 0x50b] PUSH1           0x00                                                                # Place 1 byte item on stack.
         686 [1293 0x50d] DUP1                                                                                # Duplicate 1st stack item.
         687 [1294 0x50e] RETURNDATACOPY                                                                      # Copy data from the return data buffer.
         688 [1295 0x50f] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         689 [1296 0x510] PUSH1           0x00                                                                # Place 1 byte item on stack.
         690 [1298 0x512] REVERT                                                                              # throw an error
        :loc_0x513
         691 [1299 0x513] JUMPDEST                                             JUMPI@0x509                    # Mark a valid destination for jumps.
         692 [1300 0x514] POP                                                                                 # Remove item from stack.
         693 [1301 0x515] POP                                                                                 # Remove item from stack.
         694 [1302 0x516] POP                                                                                 # Remove item from stack.
         695 [1303 0x517] POP                                                                                 # Remove item from stack.
         696 [1304 0x518] PUSH1           0x40                                                                # Place 1 byte item on stack.
         697 [1306 0x51a] MLOAD                                                                               # Load word from memory.
         698 [1307 0x51b] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         699 [1308 0x51c] PUSH1           0x20                                                                # Place 1 byte item on stack.
         700 [1310 0x51e] DUP2                                                                                # Duplicate 2nd stack item.
         701 [1311 0x51f] LT                                                                                  # Lesser-than comparison
         702 [1312 0x520] ISZERO                                                                              # Simple not operator
         703 [1313 0x521] PUSH2           0x0529                                                              # Place 2-byte item on stack.
         704 [1316 0x524] JUMPI           @0x529                                                              # Conditionally alter the program counter.
        
         705 [1317 0x525] PUSH1           0x00                                                                # Place 1 byte item on stack.
         706 [1319 0x527] DUP1                                                                                # Duplicate 1st stack item.
         707 [1320 0x528] REVERT                                                                              # throw an error
        :loc_0x529
         708 [1321 0x529] JUMPDEST                                             JUMPI@0x524                    # Mark a valid destination for jumps.
         709 [1322 0x52a] DUP2                                                                                # Duplicate 2nd stack item.
         710 [1323 0x52b] ADD                                                                                 # Addition operation.
         711 [1324 0x52c] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         712 [1325 0x52d] DUP1                                                                                # Duplicate 1st stack item.
         713 [1326 0x52e] DUP1                                                                                # Duplicate 1st stack item.
         714 [1327 0x52f] MLOAD                                                                               # Load word from memory.
         715 [1328 0x530] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         716 [1329 0x531] PUSH1           0x20                                                                # Place 1 byte item on stack.
         717 [1331 0x533] ADD                                                                                 # Addition operation.
         718 [1332 0x534] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         719 [1333 0x535] SWAP3                                                                               # Exchange 1st and 4th stack items.
         720 [1334 0x536] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         721 [1335 0x537] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         722 [1336 0x538] POP                                                                                 # Remove item from stack.
         723 [1337 0x539] POP                                                                                 # Remove item from stack.
         724 [1338 0x53a] POP                                                                                 # Remove item from stack.
         725 [1339 0x53b] POP                                                                                 # Remove item from stack.
         726 [1340 0x53c] PUSH32          0x9cf9e3ab58b33f06d81842ea0ad850b6640c6430d6396973312e1715792e7a91                                # Place 32-byte (full word) item on stack.
         727 [1373 0x55d] PUSH1           0x02                                                                # Place 1 byte item on stack.
         728 [1375 0x55f] PUSH1           0x00                                                                # Place 1 byte item on stack.
         729 [1377 0x561] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         730 [1378 0x562] SLOAD                                                                               # Load word from storage.
         731 [1379 0x563] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         732 [1380 0x564] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         733 [1383 0x567] EXP                                                                                 # Exponential operation.
         734 [1384 0x568] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         735 [1385 0x569] DIV                                                                                 # Integer division operation.
         736 [1386 0x56a] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         737 [1407 0x57f] AND                                                                                 # Bitwise AND operation.
         738 [1408 0x580] DUP3                                                                                # Duplicate 3rd stack item.
         739 [1409 0x581] PUSH1           0x40                                                                # Place 1 byte item on stack.
         740 [1411 0x583] MLOAD                                                                               # Load word from memory.
         741 [1412 0x584] DUP1                                                                                # Duplicate 1st stack item.
         742 [1413 0x585] DUP4                                                                                # Duplicate 4th stack item.
         743 [1414 0x586] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         744 [1435 0x59b] AND                                                                                 # Bitwise AND operation.
         745 [1436 0x59c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         746 [1457 0x5b1] AND                                                                                 # Bitwise AND operation.
         747 [1458 0x5b2] DUP2                                                                                # Duplicate 2nd stack item.
         748 [1459 0x5b3] MSTORE                                                                              # Save word to memory.
         749 [1460 0x5b4] PUSH1           0x20                                                                # Place 1 byte item on stack.
         750 [1462 0x5b6] ADD                                                                                 # Addition operation.
         751 [1463 0x5b7] DUP3                                                                                # Duplicate 3rd stack item.
         752 [1464 0x5b8] DUP2                                                                                # Duplicate 2nd stack item.
         753 [1465 0x5b9] MSTORE                                                                              # Save word to memory.
         754 [1466 0x5ba] PUSH1           0x20                                                                # Place 1 byte item on stack.
         755 [1468 0x5bc] ADD                                                                                 # Addition operation.
         756 [1469 0x5bd] SWAP3                                                                               # Exchange 1st and 4th stack items.
         757 [1470 0x5be] POP                                                                                 # Remove item from stack.
         758 [1471 0x5bf] POP                                                                                 # Remove item from stack.
         759 [1472 0x5c0] POP                                                                                 # Remove item from stack.
         760 [1473 0x5c1] PUSH1           0x40                                                                # Place 1 byte item on stack.
         761 [1475 0x5c3] MLOAD                                                                               # Load word from memory.
         762 [1476 0x5c4] DUP1                                                                                # Duplicate 1st stack item.
         763 [1477 0x5c5] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         764 [1478 0x5c6] SUB                                                                                 # Subtraction operation.
         765 [1479 0x5c7] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         766 [1480 0x5c8] LOG1            0x60                                                                # Append log record with one topic.
         767 [1482 0x5ca] ADD                                                                                 # Addition operation.
         768 [1483 0x5cb] PUSH1           0x02                                                                # Place 1 byte item on stack.
         769 [1485 0x5cd] PUSH1           0x15                                                                # Place 1 byte item on stack.
         770 [1487 0x5cf] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         771 [1490 0x5d2] EXP                                                                                 # Exponential operation.
         772 [1491 0x5d3] DUP2                                                                                # Duplicate 2nd stack item.
         773 [1492 0x5d4] SLOAD                                                                               # Load word from storage.
         774 [1493 0x5d5] DUP2                                                                                # Duplicate 2nd stack item.
         775 [1494 0x5d6] PUSH1           0xff                                                                # Place 1 byte item on stack.
         776 [1496 0x5d8] MUL                                                                                 # Multiplication operation.
         777 [1497 0x5d9] NOT                                                                                 # Bitwise NOT operation.
         778 [1498 0x5da] AND                                                                                 # Bitwise AND operation.
         779 [1499 0x5db] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         780 [1500 0x5dc] DUP4                                                                                # Duplicate 4th stack item.
         781 [1501 0x5dd] ISZERO                                                                              # Simple not operator
         782 [1502 0x5de] ISZERO                                                                              # Simple not operator
         783 [1503 0x5df] MUL                                                                                 # Multiplication operation.
         784 [1504 0x5e0] OR                                                                                  # Bitwise OR operation.
         785 [1505 0x5e1] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         786 [1506 0x5e2] SSTORE                                                                              # Save word to storage.
         787 [1507 0x5e3] POP                                                                                 # Remove item from stack.
         788 [1508 0x5e4] POP                                                                                 # Remove item from stack.
         789 [1509 0x5e5] JUMP                                                                                # Alter the program counter.
        
        :loc_0x5e6
         790 [1510 0x5e6] JUMPDEST                                             JUMP@0x1c2                     # Mark a valid destination for jumps.
         791 [1511 0x5e7] PUSH1           0x00                                                                # Place 1 byte item on stack.
         792 [1513 0x5e9] DUP1                                                                                # Duplicate 1st stack item.
         793 [1514 0x5ea] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         794 [1515 0x5eb] SLOAD                                                                               # Load word from storage.
         795 [1516 0x5ec] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         796 [1517 0x5ed] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         797 [1520 0x5f0] EXP                                                                                 # Exponential operation.
         798 [1521 0x5f1] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         799 [1522 0x5f2] DIV                                                                                 # Integer division operation.
         800 [1523 0x5f3] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         801 [1544 0x608] AND                                                                                 # Bitwise AND operation.
         802 [1545 0x609] DUP2                                                                                # Duplicate 2nd stack item.
         803 [1546 0x60a] JUMP                                                                                # Alter the program counter.
        
        :loc_0x60b
         804 [1547 0x60b] JUMPDEST                                             JUMP@0x219,JUMP@0x402          # Mark a valid destination for jumps.
         805 [1548 0x60c] PUSH1           0x00                                                                # Place 1 byte item on stack.
         806 [1550 0x60e] DUP1                                                                                # Duplicate 1st stack item.
         807 [1551 0x60f] TIMESTAMP                                                                           # Get the block’s timestamp.
         808 [1552 0x610] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         809 [1553 0x611] POP                                                                                 # Remove item from stack.
         810 [1554 0x612] PUSH1           0x04                                                                # Place 1 byte item on stack.
         811 [1556 0x614] SLOAD                                                                               # Load word from storage.
         812 [1557 0x615] DUP2                                                                                # Duplicate 2nd stack item.
         813 [1558 0x616] GT                                                                                  # Greater-than comparison
         814 [1559 0x617] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         815 [1560 0x618] POP                                                                                 # Remove item from stack.
         816 [1561 0x619] POP                                                                                 # Remove item from stack.
         817 [1562 0x61a] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         818 [1563 0x61b] JUMP                                                                                # Alter the program counter.
        
        :loc_0x61c
         819 [1564 0x61c] JUMPDEST                                             JUMP@0x905,JUMP@0x415,JUMP@0x248 # Mark a valid destination for jumps.
         820 [1565 0x61d] PUSH1           0x00                                                                # Place 1 byte item on stack.
         821 [1567 0x61f] PUSH1           0x01                                                                # Place 1 byte item on stack.
         822 [1569 0x621] PUSH1           0x00                                                                # Place 1 byte item on stack.
         823 [1571 0x623] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         824 [1572 0x624] SLOAD                                                                               # Load word from storage.
         825 [1573 0x625] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         826 [1574 0x626] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         827 [1577 0x629] EXP                                                                                 # Exponential operation.
         828 [1578 0x62a] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         829 [1579 0x62b] DIV                                                                                 # Integer division operation.
         830 [1580 0x62c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         831 [1601 0x641] AND                                                                                 # Bitwise AND operation.
         832 [1602 0x642] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         833 [1623 0x657] AND                                                                                 # Bitwise AND operation.
         834 [1624 0x658] PUSH4           0x70a08231  ('function balanceOf(address)')                                # Place 4-byte item on stack.
         835 [1629 0x65d] ADDRESS                                                                             # Get address of currently executing account.
         836 [1630 0x65e] PUSH1           0x40                                                                # Place 1 byte item on stack.
         837 [1632 0x660] MLOAD                                                                               # Load word from memory.
         838 [1633 0x661] DUP3                                                                                # Duplicate 3rd stack item.
         839 [1634 0x662] PUSH4           0xffffffff                                                          # Place 4-byte item on stack.
         840 [1639 0x667] AND                                                                                 # Bitwise AND operation.
         841 [1640 0x668] PUSH29          0x0100000000000000000000000000000000000000000000000000000000                                # Place 29-byte item on stack.
         842 [1670 0x686] MUL                                                                                 # Multiplication operation.
         843 [1671 0x687] DUP2                                                                                # Duplicate 2nd stack item.
         844 [1672 0x688] MSTORE                                                                              # Save word to memory.
         845 [1673 0x689] PUSH1           0x04                                                                # Place 1 byte item on stack.
         846 [1675 0x68b] ADD                                                                                 # Addition operation.
         847 [1676 0x68c] DUP1                                                                                # Duplicate 1st stack item.
         848 [1677 0x68d] DUP3                                                                                # Duplicate 3rd stack item.
         849 [1678 0x68e] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         850 [1699 0x6a3] AND                                                                                 # Bitwise AND operation.
         851 [1700 0x6a4] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         852 [1721 0x6b9] AND                                                                                 # Bitwise AND operation.
         853 [1722 0x6ba] DUP2                                                                                # Duplicate 2nd stack item.
         854 [1723 0x6bb] MSTORE                                                                              # Save word to memory.
         855 [1724 0x6bc] PUSH1           0x20                                                                # Place 1 byte item on stack.
         856 [1726 0x6be] ADD                                                                                 # Addition operation.
         857 [1727 0x6bf] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         858 [1728 0x6c0] POP                                                                                 # Remove item from stack.
         859 [1729 0x6c1] POP                                                                                 # Remove item from stack.
         860 [1730 0x6c2] PUSH1           0x20                                                                # Place 1 byte item on stack.
         861 [1732 0x6c4] PUSH1           0x40                                                                # Place 1 byte item on stack.
         862 [1734 0x6c6] MLOAD                                                                               # Load word from memory.
         863 [1735 0x6c7] DUP1                                                                                # Duplicate 1st stack item.
         864 [1736 0x6c8] DUP4                                                                                # Duplicate 4th stack item.
         865 [1737 0x6c9] SUB                                                                                 # Subtraction operation.
         866 [1738 0x6ca] DUP2                                                                                # Duplicate 2nd stack item.
         867 [1739 0x6cb] PUSH1           0x00                                                                # Place 1 byte item on stack.
         868 [1741 0x6cd] DUP8                                                                                # Duplicate 8th stack item.
         869 [1742 0x6ce] DUP1                                                                                # Duplicate 1st stack item.
         870 [1743 0x6cf] EXTCODESIZE                                                                         # Get size of an account’s code.
         871 [1744 0x6d0] ISZERO                                                                              # Simple not operator
         872 [1745 0x6d1] DUP1                                                                                # Duplicate 1st stack item.
         873 [1746 0x6d2] ISZERO                                                                              # Simple not operator
         874 [1747 0x6d3] PUSH2           0x06db                                                              # Place 2-byte item on stack.
         875 [1750 0x6d6] JUMPI           @0x6db                                                              # Conditionally alter the program counter.
        
         876 [1751 0x6d7] PUSH1           0x00                                                                # Place 1 byte item on stack.
         877 [1753 0x6d9] DUP1                                                                                # Duplicate 1st stack item.
         878 [1754 0x6da] REVERT                                                                              # throw an error
        :loc_0x6db
         879 [1755 0x6db] JUMPDEST                                             JUMPI@0x6d6                    # Mark a valid destination for jumps.
         880 [1756 0x6dc] POP                                                                                 # Remove item from stack.
         881 [1757 0x6dd] GAS                                                                                 # Get the amount of available gas, including the corresponding reduction
         882 [1758 0x6de] CALL                                                                                # Message-call into an account.
         883 [1759 0x6df] ISZERO                                                                              # Simple not operator
         884 [1760 0x6e0] DUP1                                                                                # Duplicate 1st stack item.
         885 [1761 0x6e1] ISZERO                                                                              # Simple not operator
         886 [1762 0x6e2] PUSH2           0x06ef                                                              # Place 2-byte item on stack.
         887 [1765 0x6e5] JUMPI           @0x6ef                                                              # Conditionally alter the program counter.
        
         888 [1766 0x6e6] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         889 [1767 0x6e7] PUSH1           0x00                                                                # Place 1 byte item on stack.
         890 [1769 0x6e9] DUP1                                                                                # Duplicate 1st stack item.
         891 [1770 0x6ea] RETURNDATACOPY                                                                      # Copy data from the return data buffer.
         892 [1771 0x6eb] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         893 [1772 0x6ec] PUSH1           0x00                                                                # Place 1 byte item on stack.
         894 [1774 0x6ee] REVERT                                                                              # throw an error
        :loc_0x6ef
         895 [1775 0x6ef] JUMPDEST                                             JUMPI@0x6e5                    # Mark a valid destination for jumps.
         896 [1776 0x6f0] POP                                                                                 # Remove item from stack.
         897 [1777 0x6f1] POP                                                                                 # Remove item from stack.
         898 [1778 0x6f2] POP                                                                                 # Remove item from stack.
         899 [1779 0x6f3] POP                                                                                 # Remove item from stack.
         900 [1780 0x6f4] PUSH1           0x40                                                                # Place 1 byte item on stack.
         901 [1782 0x6f6] MLOAD                                                                               # Load word from memory.
         902 [1783 0x6f7] RETURNDATASIZE                                                                      # Push the size of the return data buffer onto the stack.
         903 [1784 0x6f8] PUSH1           0x20                                                                # Place 1 byte item on stack.
         904 [1786 0x6fa] DUP2                                                                                # Duplicate 2nd stack item.
         905 [1787 0x6fb] LT                                                                                  # Lesser-than comparison
         906 [1788 0x6fc] ISZERO                                                                              # Simple not operator
         907 [1789 0x6fd] PUSH2           0x0705                                                              # Place 2-byte item on stack.
         908 [1792 0x700] JUMPI           @0x705                                                              # Conditionally alter the program counter.
        
         909 [1793 0x701] PUSH1           0x00                                                                # Place 1 byte item on stack.
         910 [1795 0x703] DUP1                                                                                # Duplicate 1st stack item.
         911 [1796 0x704] REVERT                                                                              # throw an error
        :loc_0x705
         912 [1797 0x705] JUMPDEST                                             JUMPI@0x700                    # Mark a valid destination for jumps.
         913 [1798 0x706] DUP2                                                                                # Duplicate 2nd stack item.
         914 [1799 0x707] ADD                                                                                 # Addition operation.
         915 [1800 0x708] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         916 [1801 0x709] DUP1                                                                                # Duplicate 1st stack item.
         917 [1802 0x70a] DUP1                                                                                # Duplicate 1st stack item.
         918 [1803 0x70b] MLOAD                                                                               # Load word from memory.
         919 [1804 0x70c] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         920 [1805 0x70d] PUSH1           0x20                                                                # Place 1 byte item on stack.
         921 [1807 0x70f] ADD                                                                                 # Addition operation.
         922 [1808 0x710] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         923 [1809 0x711] SWAP3                                                                               # Exchange 1st and 4th stack items.
         924 [1810 0x712] SWAP2                                                                               # Exchange 1st and 3rd stack items.
         925 [1811 0x713] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         926 [1812 0x714] POP                                                                                 # Remove item from stack.
         927 [1813 0x715] POP                                                                                 # Remove item from stack.
         928 [1814 0x716] POP                                                                                 # Remove item from stack.
         929 [1815 0x717] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         930 [1816 0x718] POP                                                                                 # Remove item from stack.
         931 [1817 0x719] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         932 [1818 0x71a] JUMP                                                                                # Alter the program counter.
        
        :loc_0x71b
         933 [1819 0x71b] JUMPDEST                                             JUMP@0x273                     # Mark a valid destination for jumps.
         934 [1820 0x71c] PUSH1           0x02                                                                # Place 1 byte item on stack.
         935 [1822 0x71e] PUSH1           0x14                                                                # Place 1 byte item on stack.
         936 [1824 0x720] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         937 [1825 0x721] SLOAD                                                                               # Load word from storage.
         938 [1826 0x722] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         939 [1827 0x723] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         940 [1830 0x726] EXP                                                                                 # Exponential operation.
         941 [1831 0x727] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         942 [1832 0x728] DIV                                                                                 # Integer division operation.
         943 [1833 0x729] PUSH1           0xff                                                                # Place 1 byte item on stack.
         944 [1835 0x72b] AND                                                                                 # Bitwise AND operation.
         945 [1836 0x72c] DUP2                                                                                # Duplicate 2nd stack item.
         946 [1837 0x72d] JUMP                                                                                # Alter the program counter.
        
        :loc_0x72e
         947 [1838 0x72e] JUMPDEST                                             JUMP@0x2ce                     # Mark a valid destination for jumps.
         948 [1839 0x72f] PUSH1           0x00                                                                # Place 1 byte item on stack.
         949 [1841 0x731] DUP1                                                                                # Duplicate 1st stack item.
         950 [1842 0x732] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         951 [1843 0x733] SLOAD                                                                               # Load word from storage.
         952 [1844 0x734] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         953 [1845 0x735] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         954 [1848 0x738] EXP                                                                                 # Exponential operation.
         955 [1849 0x739] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         956 [1850 0x73a] DIV                                                                                 # Integer division operation.
         957 [1851 0x73b] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         958 [1872 0x750] AND                                                                                 # Bitwise AND operation.
         959 [1873 0x751] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         960 [1894 0x766] AND                                                                                 # Bitwise AND operation.
         961 [1895 0x767] CALLER                                                                              # Get caller address.This is the address of the account that is directly responsible for this execution.
         962 [1896 0x768] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         963 [1917 0x77d] AND                                                                                 # Bitwise AND operation.
         964 [1918 0x77e] EQ                                                                                  # Equality  comparison
         965 [1919 0x77f] ISZERO                                                                              # Simple not operator
         966 [1920 0x780] ISZERO                                                                              # Simple not operator
         967 [1921 0x781] PUSH2           0x0789                                                              # Place 2-byte item on stack.
         968 [1924 0x784] JUMPI           @0x789                                                              # Conditionally alter the program counter.
        
         969 [1925 0x785] PUSH1           0x00                                                                # Place 1 byte item on stack.
         970 [1927 0x787] DUP1                                                                                # Duplicate 1st stack item.
         971 [1928 0x788] REVERT                                                                              # throw an error
        :loc_0x789
         972 [1929 0x789] JUMPDEST                                             JUMPI@0x784                    # Mark a valid destination for jumps.
         973 [1930 0x78a] PUSH1           0x00                                                                # Place 1 byte item on stack.
         974 [1932 0x78c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         975 [1953 0x7a1] AND                                                                                 # Bitwise AND operation.
         976 [1954 0x7a2] DUP2                                                                                # Duplicate 2nd stack item.
         977 [1955 0x7a3] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         978 [1976 0x7b8] AND                                                                                 # Bitwise AND operation.
         979 [1977 0x7b9] EQ                                                                                  # Equality  comparison
         980 [1978 0x7ba] ISZERO                                                                              # Simple not operator
         981 [1979 0x7bb] ISZERO                                                                              # Simple not operator
         982 [1980 0x7bc] ISZERO                                                                              # Simple not operator
         983 [1981 0x7bd] PUSH2           0x07c5                                                              # Place 2-byte item on stack.
         984 [1984 0x7c0] JUMPI           @0x7c5                                                              # Conditionally alter the program counter.
        
         985 [1985 0x7c1] PUSH1           0x00                                                                # Place 1 byte item on stack.
         986 [1987 0x7c3] DUP1                                                                                # Duplicate 1st stack item.
         987 [1988 0x7c4] REVERT                                                                              # throw an error
        :loc_0x7c5
         988 [1989 0x7c5] JUMPDEST                                             JUMPI@0x7c0                    # Mark a valid destination for jumps.
         989 [1990 0x7c6] DUP1                                                                                # Duplicate 1st stack item.
         990 [1991 0x7c7] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
         991 [2012 0x7dc] AND                                                                                 # Bitwise AND operation.
         992 [2013 0x7dd] PUSH1           0x00                                                                # Place 1 byte item on stack.
         993 [2015 0x7df] DUP1                                                                                # Duplicate 1st stack item.
         994 [2016 0x7e0] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         995 [2017 0x7e1] SLOAD                                                                               # Load word from storage.
         996 [2018 0x7e2] SWAP1                                                                               # Exchange 1st and 2nd stack items.
         997 [2019 0x7e3] PUSH2           0x0100                                                              # Place 2-byte item on stack.
         998 [2022 0x7e6] EXP                                                                                 # Exponential operation.
         999 [2023 0x7e7] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1000 [2024 0x7e8] DIV                                                                                 # Integer division operation.
        1001 [2025 0x7e9] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1002 [2046 0x7fe] AND                                                                                 # Bitwise AND operation.
        1003 [2047 0x7ff] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1004 [2068 0x814] AND                                                                                 # Bitwise AND operation.
        1005 [2069 0x815] PUSH32          0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0                                # Place 32-byte (full word) item on stack.
        1006 [2102 0x836] PUSH1           0x40                                                                # Place 1 byte item on stack.
        1007 [2104 0x838] MLOAD                                                                               # Load word from memory.
        1008 [2105 0x839] PUSH1           0x40                                                                # Place 1 byte item on stack.
        1009 [2107 0x83b] MLOAD                                                                               # Load word from memory.
        1010 [2108 0x83c] DUP1                                                                                # Duplicate 1st stack item.
        1011 [2109 0x83d] SWAP2                                                                               # Exchange 1st and 3rd stack items.
        1012 [2110 0x83e] SUB                                                                                 # Subtraction operation.
        1013 [2111 0x83f] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1014 [2112 0x840] LOG3            0x806000                                                            # Append log record with three topics.
        1015 [2116 0x844] DUP1                                                                                # Duplicate 1st stack item.
        1016 [2117 0x845] PUSH2           0x0100                                                              # Place 2-byte item on stack.
        1017 [2120 0x848] EXP                                                                                 # Exponential operation.
        1018 [2121 0x849] DUP2                                                                                # Duplicate 2nd stack item.
        1019 [2122 0x84a] SLOAD                                                                               # Load word from storage.
        1020 [2123 0x84b] DUP2                                                                                # Duplicate 2nd stack item.
        1021 [2124 0x84c] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1022 [2145 0x861] MUL                                                                                 # Multiplication operation.
        1023 [2146 0x862] NOT                                                                                 # Bitwise NOT operation.
        1024 [2147 0x863] AND                                                                                 # Bitwise AND operation.
        1025 [2148 0x864] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1026 [2149 0x865] DUP4                                                                                # Duplicate 4th stack item.
        1027 [2150 0x866] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1028 [2171 0x87b] AND                                                                                 # Bitwise AND operation.
        1029 [2172 0x87c] MUL                                                                                 # Multiplication operation.
        1030 [2173 0x87d] OR                                                                                  # Bitwise OR operation.
        1031 [2174 0x87e] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1032 [2175 0x87f] SSTORE                                                                              # Save word to storage.
        1033 [2176 0x880] POP                                                                                 # Remove item from stack.
        1034 [2177 0x881] POP                                                                                 # Remove item from stack.
        1035 [2178 0x882] JUMP                                                                                # Alter the program counter.
        
        :loc_0x883
        1036 [2179 0x883] JUMPDEST                                             JUMP@0x2e5                     # Mark a valid destination for jumps.
        1037 [2180 0x884] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1038 [2182 0x886] DUP1                                                                                # Duplicate 1st stack item.
        1039 [2183 0x887] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1040 [2185 0x889] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1041 [2186 0x88a] SLOAD                                                                               # Load word from storage.
        1042 [2187 0x88b] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1043 [2188 0x88c] PUSH2           0x0100                                                              # Place 2-byte item on stack.
        1044 [2191 0x88f] EXP                                                                                 # Exponential operation.
        1045 [2192 0x890] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1046 [2193 0x891] DIV                                                                                 # Integer division operation.
        1047 [2194 0x892] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1048 [2215 0x8a7] AND                                                                                 # Bitwise AND operation.
        1049 [2216 0x8a8] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1050 [2237 0x8bd] AND                                                                                 # Bitwise AND operation.
        1051 [2238 0x8be] CALLER                                                                              # Get caller address.This is the address of the account that is directly responsible for this execution.
        1052 [2239 0x8bf] PUSH20          0xffffffffffffffffffffffffffffffffffffffff                                # Place 20-byte item on stack.
        1053 [2260 0x8d4] AND                                                                                 # Bitwise AND operation.
        1054 [2261 0x8d5] EQ                                                                                  # Equality  comparison
        1055 [2262 0x8d6] ISZERO                                                                              # Simple not operator
        1056 [2263 0x8d7] ISZERO                                                                              # Simple not operator
        1057 [2264 0x8d8] PUSH2           0x08e0                                                              # Place 2-byte item on stack.
        1058 [2267 0x8db] JUMPI           @0x8e0                                                              # Conditionally alter the program counter.
        
        1059 [2268 0x8dc] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1060 [2270 0x8de] DUP1                                                                                # Duplicate 1st stack item.
        1061 [2271 0x8df] REVERT                                                                              # throw an error
        :loc_0x8e0
        1062 [2272 0x8e0] JUMPDEST                                             JUMPI@0x8db                    # Mark a valid destination for jumps.
        1063 [2273 0x8e1] PUSH1           0x02                                                                # Place 1 byte item on stack.
        1064 [2275 0x8e3] PUSH1           0x14                                                                # Place 1 byte item on stack.
        1065 [2277 0x8e5] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1066 [2278 0x8e6] SLOAD                                                                               # Load word from storage.
        1067 [2279 0x8e7] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1068 [2280 0x8e8] PUSH2           0x0100                                                              # Place 2-byte item on stack.
        1069 [2283 0x8eb] EXP                                                                                 # Exponential operation.
        1070 [2284 0x8ec] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1071 [2285 0x8ed] DIV                                                                                 # Integer division operation.
        1072 [2286 0x8ee] PUSH1           0xff                                                                # Place 1 byte item on stack.
        1073 [2288 0x8f0] AND                                                                                 # Bitwise AND operation.
        1074 [2289 0x8f1] ISZERO                                                                              # Simple not operator
        1075 [2290 0x8f2] ISZERO                                                                              # Simple not operator
        1076 [2291 0x8f3] ISZERO                                                                              # Simple not operator
        1077 [2292 0x8f4] PUSH2           0x08fc                                                              # Place 2-byte item on stack.
        1078 [2295 0x8f7] JUMPI           @0x8fc                                                              # Conditionally alter the program counter.
        
        1079 [2296 0x8f8] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1080 [2298 0x8fa] DUP1                                                                                # Duplicate 1st stack item.
        1081 [2299 0x8fb] REVERT                                                                              # throw an error
        :loc_0x8fc
        1082 [2300 0x8fc] JUMPDEST                                             JUMPI@0x8f7                    # Mark a valid destination for jumps.
        1083 [2301 0x8fd] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1084 [2303 0x8ff] PUSH2           0x0906                                                              # Place 2-byte item on stack.
        1085 [2306 0x902] PUSH2           0x061c                                                              # Place 2-byte item on stack.
        1086 [2309 0x905] JUMP            @0x61c                                                              # Alter the program counter.
        
        :loc_0x906
        1087 [2310 0x906] JUMPDEST                                                                            # Mark a valid destination for jumps.
        1088 [2311 0x907] GT                                                                                  # Greater-than comparison
        1089 [2312 0x908] ISZERO                                                                              # Simple not operator
        1090 [2313 0x909] ISZERO                                                                              # Simple not operator
        1091 [2314 0x90a] PUSH2           0x0912                                                              # Place 2-byte item on stack.
        1092 [2317 0x90d] JUMPI           @0x912                                                              # Conditionally alter the program counter.
        
        1093 [2318 0x90e] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1094 [2320 0x910] DUP1                                                                                # Duplicate 1st stack item.
        1095 [2321 0x911] REVERT                                                                              # throw an error
        :loc_0x912
        1096 [2322 0x912] JUMPDEST                                             JUMPI@0x90d                    # Mark a valid destination for jumps.
        1097 [2323 0x913] TIMESTAMP                                                                           # Get the block’s timestamp.
        1098 [2324 0x914] PUSH1           0x03                                                                # Place 1 byte item on stack.
        1099 [2326 0x916] DUP2                                                                                # Duplicate 2nd stack item.
        1100 [2327 0x917] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1101 [2328 0x918] SSTORE                                                                              # Save word to storage.
        1102 [2329 0x919] POP                                                                                 # Remove item from stack.
        1103 [2330 0x91a] PUSH2           0x0930                                                              # Place 2-byte item on stack.
        1104 [2333 0x91d] PUSH1           0x05                                                                # Place 1 byte item on stack.
        1105 [2335 0x91f] SLOAD                                                                               # Load word from storage.
        1106 [2336 0x920] PUSH1           0x03                                                                # Place 1 byte item on stack.
        1107 [2338 0x922] SLOAD                                                                               # Load word from storage.
        1108 [2339 0x923] PUSH2           0x0967                                                              # Place 2-byte item on stack.
        1109 [2342 0x926] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1110 [2343 0x927] SWAP2                                                                               # Exchange 1st and 3rd stack items.
        1111 [2344 0x928] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1112 [2345 0x929] PUSH4           0xffffffff                                                          # Place 4-byte item on stack.
        1113 [2350 0x92e] AND                                                                                 # Bitwise AND operation.
        1114 [2351 0x92f] JUMP                                                                                # Alter the program counter.
        
        :loc_0x930
        1115 [2352 0x930] JUMPDEST                                                                            # Mark a valid destination for jumps.
        1116 [2353 0x931] PUSH1           0x04                                                                # Place 1 byte item on stack.
        1117 [2355 0x933] DUP2                                                                                # Duplicate 2nd stack item.
        1118 [2356 0x934] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1119 [2357 0x935] SSTORE                                                                              # Save word to storage.
        1120 [2358 0x936] POP                                                                                 # Remove item from stack.
        1121 [2359 0x937] PUSH1           0x01                                                                # Place 1 byte item on stack.
        1122 [2361 0x939] PUSH1           0x02                                                                # Place 1 byte item on stack.
        1123 [2363 0x93b] PUSH1           0x14                                                                # Place 1 byte item on stack.
        1124 [2365 0x93d] PUSH2           0x0100                                                              # Place 2-byte item on stack.
        1125 [2368 0x940] EXP                                                                                 # Exponential operation.
        1126 [2369 0x941] DUP2                                                                                # Duplicate 2nd stack item.
        1127 [2370 0x942] SLOAD                                                                               # Load word from storage.
        1128 [2371 0x943] DUP2                                                                                # Duplicate 2nd stack item.
        1129 [2372 0x944] PUSH1           0xff                                                                # Place 1 byte item on stack.
        1130 [2374 0x946] MUL                                                                                 # Multiplication operation.
        1131 [2375 0x947] NOT                                                                                 # Bitwise NOT operation.
        1132 [2376 0x948] AND                                                                                 # Bitwise AND operation.
        1133 [2377 0x949] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1134 [2378 0x94a] DUP4                                                                                # Duplicate 4th stack item.
        1135 [2379 0x94b] ISZERO                                                                              # Simple not operator
        1136 [2380 0x94c] ISZERO                                                                              # Simple not operator
        1137 [2381 0x94d] MUL                                                                                 # Multiplication operation.
        1138 [2382 0x94e] OR                                                                                  # Bitwise OR operation.
        1139 [2383 0x94f] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1140 [2384 0x950] SSTORE                                                                              # Save word to storage.
        1141 [2385 0x951] POP                                                                                 # Remove item from stack.
        1142 [2386 0x952] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1143 [2387 0x953] JUMP                                                                                # Alter the program counter.
        
        :loc_0x954
        1144 [2388 0x954] JUMPDEST                                             JUMP@0x314                     # Mark a valid destination for jumps.
        1145 [2389 0x955] PUSH1           0x02                                                                # Place 1 byte item on stack.
        1146 [2391 0x957] PUSH1           0x15                                                                # Place 1 byte item on stack.
        1147 [2393 0x959] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1148 [2394 0x95a] SLOAD                                                                               # Load word from storage.
        1149 [2395 0x95b] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1150 [2396 0x95c] PUSH2           0x0100                                                              # Place 2-byte item on stack.
        1151 [2399 0x95f] EXP                                                                                 # Exponential operation.
        1152 [2400 0x960] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1153 [2401 0x961] DIV                                                                                 # Integer division operation.
        1154 [2402 0x962] PUSH1           0xff                                                                # Place 1 byte item on stack.
        1155 [2404 0x964] AND                                                                                 # Bitwise AND operation.
        1156 [2405 0x965] DUP2                                                                                # Duplicate 2nd stack item.
        1157 [2406 0x966] JUMP                                                                                # Alter the program counter.
        
        :loc_0x967
        1158 [2407 0x967] JUMPDEST                                                                            # Mark a valid destination for jumps.
        1159 [2408 0x968] PUSH1           0x00                                                                # Place 1 byte item on stack.
        1160 [2410 0x96a] DUP1                                                                                # Duplicate 1st stack item.
        1161 [2411 0x96b] DUP3                                                                                # Duplicate 3rd stack item.
        1162 [2412 0x96c] DUP5                                                                                # Duplicate 5th stack item.
        1163 [2413 0x96d] ADD                                                                                 # Addition operation.
        1164 [2414 0x96e] SWAP1                                                                               # Exchange 1st and 2nd stack items.
        1165 [2415 0x96f] POP                                                                                 # Remove item from stack.
        1166 [2416 0x970] DUP4                                                                                # Duplicate 4th stack item.
        1167 [2417 0x971] DUP2                                                                                # Duplicate 2nd stack item.
        1168 [2418 0x972] LT                                                                                  # Lesser-than comparison
        1169 [2419 0x973] ISZERO                                                                              # Simple not operator
        1170 [2420 0x974] ISZERO                                                                              # Simple not operator
        1171 [2421 0x975] ISZERO                                                                              # Simple not operator
        1172 [2422 0x976] PUSH2           0x097b                                                              # Place 2-byte item on stack.
        1173 [2425 0x979] JUMPI           @0x97b                                                              # Conditionally alter the program counter.
        
        1174 [2426 0x97a] UNKNOWN_0xfe                                                                        # Invalid opcode
        :loc_0x97b
        1175 [2427 0x97b] JUMPDEST                                             JUMPI@0x979                    # Mark a valid destination for jumps.
        1176 [2428 0x97c] DUP1                                                                                # Duplicate 1st stack item.
        1177 [2429 0x97d] SWAP2                                                                               # Exchange 1st and 3rd stack items.
        1178 [2430 0x97e] POP                                                                                 # Remove item from stack.
        1179 [2431 0x97f] POP                                                                                 # Remove item from stack.
        1180 [2432 0x980] SWAP3                                                                               # Exchange 1st and 4th stack items.
        1181 [2433 0x981] SWAP2                                                                               # Exchange 1st and 3rd stack items.
        1182 [2434 0x982] POP                                                                                 # Remove item from stack.
        1183 [2435 0x983] POP                                                                                 # Remove item from stack.
        1184 [2436 0x984] JUMP                                                                                # Alter the program counter.
        
        1185 [2437 0x985] STOP                                                                                # Halts execution.
        
        1186 [2438 0x986] LOG1            0x65                                                                # Append log record with one topic.
        1187 [2440 0x988] PUSH3           0x7a7a72                                                            # Place 3-byte item on stack.
        1188 [2444 0x98c] ADDRESS                                                                             # Get address of currently executing account.
        1189 [2445 0x98d] PC                                                                                  # Get the value of the program counter prior to the increment.
        1190 [2446 0x98e] SHA3                                                                                # Compute Keccak-256 hash.
        1191 [2447 0x98f] PUSH10          0x642cdfbf8b49cb944b12                                              # Place 10-byte item on stack.
        1192 [2458 0x99a] ORIGIN                                                                              # Get execution origination address.
        1193 [2459 0x99b] DUP11                                                                               # Duplicate 11th stack item.
        1194 [2460 0x99c] UNKNOWN_0xdd                                                                        # Invalid opcode
        1195 [2461 0x99d] UNKNOWN_0x2c                                                                        # Invalid opcode
        1196 [2462 0x99e] DUP2                                                                                # Duplicate 2nd stack item.
        1197 [2463 0x99f] UNKNOWN_0xc3                                                                        # Invalid opcode
        1198 [2464 0x9a0] SSTORE                                                                              # Save word to storage.
        1199 [2465 0x9a1] PUSH23          0x00ed88f94b907c0d547a6251db0029                                    # Place 23-byte item on stack.
        ```
        
Keywords: ethereum,blockchain,evm,disassembler
Platform: UNKNOWN
