import struct
import unittest
import json
from manticore.platforms import evm
from manticore.core import state
from manticore.core.smtlib import Operators, ConstraintSet
import os


class EVMTest_EXP(unittest.TestCase):
    _multiprocess_can_split_ = True
    maxDiff = None

    def _execute(self, new_vm):
        last_returned = None
        last_exception = None
        try:
            new_vm.execute()
        except evm.Stop as e:
            last_exception = "STOP"
        except evm.NotEnoughGas:
            last_exception = "OOG"
        except evm.StackUnderflow:
            last_exception = "INSUFFICIENT STACK"
        except evm.InvalidOpcode:
            last_exception = "INVALID"
        except evm.SelfDestruct:
            last_exception = "SUICIDED"
        except evm.Return as e:
            last_exception = "RETURN"
            last_returned = e.data
        except evm.Revert:
            last_exception = "REVERT"

        return last_exception, last_returned

    def test_EXP_1(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [115792089237316195423570985008687907853269984665640564039457584007913129639935],
        )

    def test_EXP_2(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_3(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_4(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_5(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [104454113832828984621679659393253883542637298667129925477260695573804969029359],
        )

    def test_EXP_6(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_7(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_8(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_9(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_10(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_11(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_12(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_13(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_14(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_15(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_16(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_17(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_18(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_19(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_20(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_21(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_22(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_23(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_24(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_25(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_26(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_27(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_28(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_29(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_30(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_31(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])

    def test_EXP_32(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [97153515582439856940218076430383148080316642374323115531717460774015781538049],
        )

    def test_EXP_33(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_34(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_35(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_36(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_37(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [115792089237316195423570985008687907853269984665640564039457584007913129639935],
        )

    def test_EXP_38(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_39(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_40(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])

    def test_EXP_41(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [112173586448650064316584391727166410732855297644839296413224972401556225198063],
        )

    def test_EXP_42(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_43(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_44(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_45(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_46(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_47(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_48(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_49(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [18446744073709551616])

    def test_EXP_50(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [57896044618658097711785492504343953926634992332820282019735360412312277710593],
        )

    def test_EXP_51(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [18446744073709551616])

    def test_EXP_52(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1208925819614629174706176])

    def test_EXP_53(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [794071845499378503449051136])

    def test_EXP_54(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [8303694420805298775410959586403913600201715917447438497573206049841934761984],
        )

    def test_EXP_55(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_56(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_57(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_58(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [340282366920938463463374607431768211456])

    def test_EXP_59(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [43143988327398919500410556793212890625])

    def test_EXP_60(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [340282366920938463463374607431768211456])

    def test_EXP_61(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1461501637330902918203684832716283019655932542976])

    def test_EXP_62(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [630550095814788844423632687832745817333905738742890496])

    def test_EXP_63(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])

    def test_EXP_64(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_65(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_66(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_67(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [6277101735386680763835789423207666416102355444464034512896])

    def test_EXP_68(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [57896044618658097712068879837772420409703173580337995947392654709187277710593],
        )

    def test_EXP_69(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [6277101735386680763835789423207666416102355444464034512896])

    def test_EXP_70(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [1766847064778384329583297500742918515827483896875618958121606201292619776],
        )

    def test_EXP_71(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [17084401304090163016086072004374689170541683170424114643147834605304589320192],
        )

    def test_EXP_72(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])

    def test_EXP_73(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_74(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_75(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [1])

    def test_EXP_76(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])

    def test_EXP_77(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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,
            [42192513242301740010671492996252704544191162524312342410321251717326910681089],
        )

    def test_EXP_78(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_79(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_80(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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_EXP_81(self):
        # Make the constraint store
        constraints = ConstraintSet()
        # make the ethereum world state
        world = evm.EVMWorld(constraints)

        address = 0x222222222222222222222222222222222222200
        caller = origin = 0x111111111111111111111111111111111111100
        price = 0
        value = 10000
        bytecode = b"\n"
        data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
        header = {"coinbase": 0, "timestamp": 0, "number": 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, [0])


if __name__ == "__main__":
    unittest.main()
