
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 as 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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [31])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [15])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602495])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [226156424291633194186662080095093570025917938800079226639565593765455331328])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650623])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [113078212145816597093331040047546785012958969400039613319782796882727665664])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [2412335192444087404657728854347664746943124680534178417488699666831523534165])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [1206167596222043702328864427173832373471562340267089208744349833415761767082])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [75385474763877731395554026698364523341972646266693075546521864588485110442])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [19014759003423441022450548080640])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [9507379501711720511225274040320])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [594211218856982531951579627520])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(6089590155545428825848686802984512581899718912)
            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()

55119071288b49433f4f6224f32312ed3da9176f
<mask token>


class EVMTest_DIV(unittest.TestCase):
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_2(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(0)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_4(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_7(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(32)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_9(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_13(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_15(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_20(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            ])

    def test_DIV_23(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            ])
    <mask token>

    def test_DIV_25(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            6089590155545428825848686802984512581899718912])
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_31(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        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])
    <mask token>

    def test_DIV_33(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(16)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_36(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_38(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(0)
        last_exception, last_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_39(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(1)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_42(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(16)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_44(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(48)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_46(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            7237005577332262213973186563042994240829374041602535252466099000494570602495
            ])

    def test_DIV_47(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_50(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            226156424291633194186662080095093570025917938800079226639565593765455331328
            ])

    def test_DIV_51(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_54(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            380599384721589301615542925186532036368732432])

    def test_DIV_55(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])
    <mask token>
    <mask token>

    def test_DIV_58(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1809251394333065553493296640760748560207343510400633813116524750123642650623
            ])
    <mask token>
    <mask token>

    def test_DIV_61(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_64(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            2412335192444087404657728854347664746943124680534178417488699666831523534165
            ])

    def test_DIV_65(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_67(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1206167596222043702328864427173832373471562340267089208744349833415761767082
            ])

    def test_DIV_68(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            75385474763877731395554026698364523341972646266693075546521864588485110442
            ])
    <mask token>

    def test_DIV_70(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_75(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(1)
        last_exception, last_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_76(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [9507379501711720511225274040320])
    <mask token>

    def test_DIV_78(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(16)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>
    <mask token>


<mask token>

<mask token>


class EVMTest_DIV(unittest.TestCase):
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_1(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        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_2(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(0)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_4(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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_5(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_7(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(32)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_9(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_11(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_13(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            ])

    def test_DIV_20(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            ])

    def test_DIV_23(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            ])
    <mask token>

    def test_DIV_25(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            6089590155545428825848686802984512581899718912])
    <mask token>

    def test_DIV_29(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(0)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_31(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        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])
    <mask token>

    def test_DIV_33(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(16)
        last_exception, last_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_34(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(32)
        last_exception, last_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_35(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(48)
        last_exception, last_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_36(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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_37(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [31])

    def test_DIV_38(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(0)
        last_exception, last_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_39(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(1)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_42(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(16)
        last_exception, last_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_43(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(32)
        last_exception, last_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_44(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(48)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_46(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            7237005577332262213973186563042994240829374041602535252466099000494570602495
            ])

    def test_DIV_47(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_50(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            226156424291633194186662080095093570025917938800079226639565593765455331328
            ])

    def test_DIV_51(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_54(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            380599384721589301615542925186532036368732432])

    def test_DIV_55(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])
    <mask token>

    def test_DIV_57(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1809251394333065553493296640760748560207343510400633813116524750123642650623
            ])
    <mask token>

    def test_DIV_60(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            190299692360794650807771462593266018184366216])

    def test_DIV_64(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            2412335192444087404657728854347664746943124680534178417488699666831523534165
            ])

    def test_DIV_65(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1206167596222043702328864427173832373471562340267089208744349833415761767082
            ])

    def test_DIV_68(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            75385474763877731395554026698364523341972646266693075546521864588485110442
            ])
    <mask token>

    def test_DIV_70(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_73(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [19014759003423441022450548080640])
    <mask token>

    def test_DIV_75(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(1)
        last_exception, last_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_76(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [9507379501711720511225274040320])
    <mask token>

    def test_DIV_78(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(16)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>
    <mask token>


<mask token>

<mask token>


class EVMTest_DIV(unittest.TestCase):
    <mask token>
    <mask token>
    <mask token>

    def test_DIV_1(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        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_2(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(0)
        last_exception, last_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_3(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(1)
        last_exception, last_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_4(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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_5(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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_6(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(16)
        last_exception, last_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_7(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(32)
        last_exception, last_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_8(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(48)
        last_exception, last_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_9(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_11(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            ])

    def test_DIV_20(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            ])

    def test_DIV_23(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            ])

    def test_DIV_24(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            6089590155545428825848686802984512581899718912])

    def test_DIV_28(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        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_29(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(0)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_31(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        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])
    <mask token>

    def test_DIV_33(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(16)
        last_exception, last_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_34(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(32)
        last_exception, last_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_35(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(48)
        last_exception, last_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_36(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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_37(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [31])

    def test_DIV_38(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(0)
        last_exception, last_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_39(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(1)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_42(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(16)
        last_exception, last_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_43(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(32)
        last_exception, last_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_44(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(48)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>

    def test_DIV_46(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            7237005577332262213973186563042994240829374041602535252466099000494570602495
            ])

    def test_DIV_47(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])

    def test_DIV_50(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            226156424291633194186662080095093570025917938800079226639565593765455331328
            ])

    def test_DIV_51(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            380599384721589301615542925186532036368732432])

    def test_DIV_55(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])
    <mask token>

    def test_DIV_57(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1809251394333065553493296640760748560207343510400633813116524750123642650623
            ])
    <mask token>

    def test_DIV_60(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            190299692360794650807771462593266018184366216])

    def test_DIV_64(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            2412335192444087404657728854347664746943124680534178417488699666831523534165
            ])

    def test_DIV_65(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1206167596222043702328864427173832373471562340267089208744349833415761767082
            ])

    def test_DIV_68(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            75385474763877731395554026698364523341972646266693075546521864588485110442
            ])
    <mask token>

    def test_DIV_70(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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])
    <mask token>

    def test_DIV_73(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [19014759003423441022450548080640])

    def test_DIV_74(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(0)
        last_exception, last_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_75(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(1)
        last_exception, last_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_76(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [9507379501711720511225274040320])
    <mask token>

    def test_DIV_78(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(16)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [0])
    <mask token>
    <mask token>

    def test_DIV_81(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(6089590155545428825848686802984512581899718912)
        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])


<mask token>

<mask token>


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 as 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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        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_2(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(0)
        last_exception, last_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_3(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(1)
        last_exception, last_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_4(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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_5(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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_6(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(16)
        last_exception, last_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_7(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(32)
        last_exception, last_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_8(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(48)
        last_exception, last_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_9(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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_10(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(0)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            ])

    def test_DIV_20(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            ])

    def test_DIV_23(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            ])

    def test_DIV_24(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(1)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            6089590155545428825848686802984512581899718912])

    def test_DIV_28(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        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_29(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(0)
        last_exception, last_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_30(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(1)
        last_exception, last_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_31(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        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_32(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_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_33(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(16)
        last_exception, last_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_34(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(32)
        last_exception, last_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_35(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(48)
        last_exception, last_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_36(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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_37(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [31])

    def test_DIV_38(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(0)
        last_exception, last_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_39(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(1)
        last_exception, last_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_40(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [15])

    def test_DIV_41(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        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_42(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(16)
        last_exception, last_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_43(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(32)
        last_exception, last_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_44(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(48)
        last_exception, last_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_45(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_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_46(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            7237005577332262213973186563042994240829374041602535252466099000494570602495
            ])

    def test_DIV_47(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])

    def test_DIV_50(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            226156424291633194186662080095093570025917938800079226639565593765455331328
            ])

    def test_DIV_51(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(16)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            380599384721589301615542925186532036368732432])

    def test_DIV_55(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            3618502788666131106986593281521497120414687020801267626233049500247285301247
            ])

    def test_DIV_56(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1809251394333065553493296640760748560207343510400633813116524750123642650623
            ])

    def test_DIV_59(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            113078212145816597093331040047546785012958969400039613319782796882727665664
            ])

    def test_DIV_60(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(32)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            190299692360794650807771462593266018184366216])

    def test_DIV_64(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            2412335192444087404657728854347664746943124680534178417488699666831523534165
            ])

    def test_DIV_65(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            1206167596222043702328864427173832373471562340267089208744349833415761767082
            ])

    def test_DIV_68(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            75385474763877731395554026698364523341972646266693075546521864588485110442
            ])

    def test_DIV_69(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        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):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(48)
        new_vm._push(6089590155545428825848686802984512581899718912)
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [
            126866461573863100538514308395510678789577477])

    def test_DIV_73(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            115792089237316195423570985008687907853269984665640564039457584007913129639935
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [19014759003423441022450548080640])

    def test_DIV_74(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(0)
        last_exception, last_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_75(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(1)
        last_exception, last_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_76(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            57896044618658097711785492504343953926634992332820282019728792003956564819952
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [9507379501711720511225274040320])

    def test_DIV_77(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(
            3618502788666131106986593281521497120414687020801267626233049500247285301263
            )
        last_exception, last_returned = self._execute(new_vm)
        self.assertEqual(last_exception, None)
        self.assertEqual(new_vm.pc, 1)
        self.assertEqual(new_vm.stack, [594211218856982531951579627520])

    def test_DIV_78(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(16)
        last_exception, last_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_79(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(32)
        last_exception, last_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_80(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(48)
        last_exception, last_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_81(self):
        constraints = ConstraintSet()
        world = evm.EVMWorld(constraints)
        address = 12179180311090857651697373605969025163799437824
        caller = origin = 6089590155545428825848686802984512581899718912
        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, data, caller, value,
            bytecode, gas=gas, world=world)
        new_vm._push(6089590155545428825848686802984512581899718912)
        new_vm._push(6089590155545428825848686802984512581899718912)
        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])


<mask token>


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 as 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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(0)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [115792089237316195423570985008687907853269984665640564039457584007913129639935])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [57896044618658097711785492504343953926634992332820282019728792003956564819952])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301263])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(1)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [31])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [15])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [7237005577332262213973186563042994240829374041602535252466099000494570602495])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [226156424291633194186662080095093570025917938800079226639565593765455331328])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(16)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [3618502788666131106986593281521497120414687020801267626233049500247285301247])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [1809251394333065553493296640760748560207343510400633813116524750123642650623])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [113078212145816597093331040047546785012958969400039613319782796882727665664])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(32)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [2412335192444087404657728854347664746943124680534178417488699666831523534165])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [1206167596222043702328864427173832373471562340267089208744349833415761767082])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [75385474763877731395554026698364523341972646266693075546521864588485110442])

    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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(48)
            new_vm._push(6089590155545428825848686802984512581899718912)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [19014759003423441022450548080640])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(0)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(1)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [9507379501711720511225274040320])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263)
            last_exception, last_returned = self._execute(new_vm)
            self.assertEqual(last_exception, None)
            self.assertEqual(new_vm.pc, 1)
            self.assertEqual(new_vm.stack, [594211218856982531951579627520])

    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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(16)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(32)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(48)
            last_exception, last_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_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, data, caller, value, bytecode, gas=gas, world=world)
            new_vm._push(6089590155545428825848686802984512581899718912)
            new_vm._push(6089590155545428825848686802984512581899718912)
            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()
