Fix merge conflicts

.circleci/config.yml

@@ -108,12 +108,14 @@ jobs:
           command: sleep 15s
       - run:
           name: Quick Edelweiss test
-          command: /home/run-edelweiss-test.sh CircleCI/latest.quick.csv
-      - run:
-          name: Full Edelweiss test
-          environment:
-            MYTHX_API_FULL_MODE: true
-          command: /home/run-edelweiss-test.sh CircleCI/latest.full.csv
+          command: /home/run-edelweiss-test.sh CircleCI/latest.quick.csv 5
+
+      # TODO: Temporary disabled
+      # - run:
+      #    name: Full Edelweiss test
+      #    environment:
+      #      MYTHX_API_FULL_MODE: true
+      #    command: /home/run-edelweiss-test.sh CircleCI/latest.full.csv
 
   pypi_release:
     <<: *defaults

Dockerfile

@@ -1,5 +1,8 @@
 FROM ubuntu:bionic
 
+# Space-separated version string without leading 'v' (e.g. "0.4.21 0.4.22") 
+ARG SOLC
+
 RUN apt-get update \
   && apt-get install -y \
      libsqlite3-0 \
@@ -36,5 +39,10 @@ COPY . /opt/mythril
 RUN cd /opt/mythril \
   && python setup.py install
 
-COPY ./mythril/support/assets/signatures.db /root/.mythril/signatures.db
+WORKDIR /home/mythril
+
+RUN ( [ ! -z "${SOLC}" ] && set -e && for ver in $SOLC; do python -m solc.install v${ver}; done ) || true
+
+COPY ./mythril/support/assets/signatures.db /home/mythril/.mythril/signatures.db
+
 ENTRYPOINT ["/usr/local/bin/myth"]

Pipfile

@@ -1,19 +0,0 @@
-[[source]]
-url = "https://pypi.python.org/simple"
-verify_ssl = true
-name = "pypi"
-
-[packages]
-"e1839a8" = {path = ".", editable = true}
-
-[dev-packages]
-pylint = "*"
-yapf = "*"
-pytest = "*"
-pytest-mock = "*"
-pytest-cov = "*"
-
-[requires]
-
-[pipenv]
-allow_prereleases = true

README.md

@@ -1,4 +1,4 @@
-# Mythril Classic
+# Mythril
 
 <p align="center">
 	<img src="/static/mythril_new.png" height="320px"/>
@@ -6,18 +6,15 @@
 
 [![Discord](https://img.shields.io/discord/481002907366588416.svg)](https://discord.gg/E3YrVtG)
 [![PyPI](https://badge.fury.io/py/mythril.svg)](https://pypi.python.org/pypi/mythril)
-[![Read the Docs](https://readthedocs.org/projects/mythril-classic/badge/?version=master)](https://mythril-classic.readthedocs.io/en/master/)
-![Master Build Status](https://img.shields.io/circleci/project/github/ConsenSys/mythril-classic/master.svg)
-[![Waffle.io - Columns and their card count](https://badge.waffle.io/ConsenSys/mythril-classic.svg?columns=In%20Progress)](https://waffle.io/ConsenSys/mythril-classic/)
+[![Read the Docs](https://readthedocs.org/projects/mythril/badge/?version=master)](https://mythril.readthedocs.io/en/master/)
+![Master Build Status](https://img.shields.io/circleci/build/github/ConsenSys/mythril.svg?token=97124ecfaee54366859cae98b5dafc0714325f8b)
 [![Sonarcloud - Maintainability](https://sonarcloud.io/api/project_badges/measure?project=mythril&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=mythril)
-[![Downloads](https://pepy.tech/badge/mythril)](https://pepy.tech/project/mythril)
+[![Pypi Installs](https://pepy.tech/badge/mythril)](https://pepy.tech/project/mythril)
+[![DockerHub Pulls](https://img.shields.io/docker/pulls/mythril/myth.svg?label=DockerHub&nbsp;Pulls)](https://cloud.docker.com/u/mythril/repository/docker/mythril/myth)
 
-Mythril Classic is an open-source security analysis tool for Ethereum smart contracts. It uses symbolic analysis, taint analysis and control flow checking to detect a variety of security vulnerabilities.
+Mythril is a security analysis tool for EVM bytecode. It detects security vulnerabilities in smart contracts built for Ethereum, Quorum, Vechain, Roostock, Tron and other EVM-compatible blockchains. It uses symbolic execution, SMT solving and taint analysis detect a variety of security vulnerabilities. It's also used (in combination with other tools and techniques) in the [MythX](https://mythx.io) security analysis platform.
 
-Note that Mythril Classic is designed for security auditors. If you are a smart contract developer, we recommend using [MythX tools](https://github.com/b-mueller/awesome-mythx-smart-contract-security) which are optimized for usability and cover a wider range of security issues:
-
-- [Sabre](https://github.com/b-mueller/sabre)
-- [MythX Plugin for Truffle](https://github.com/ConsenSys/truffle-security)
+If you are a smart contract developer, we recommend using [MythX tools](https://github.com/b-mueller/awesome-mythx-smart-contract-security) which are optimized for usability and cover a wider range of security issues.
 
 Whether you want to contribute, need support, or want to learn what we have cooking for the future, our [Discord server](https://discord.gg/E3YrVtG) will serve your needs.
 
@@ -39,12 +36,12 @@ See the [Wiki](https://github.com/ConsenSys/mythril/wiki/Installation-and-Setup)
 
 ## Usage
 
-Instructions for using Mythril Classic are found on the [Wiki](https://github.com/ConsenSys/mythril-classic/wiki). 
+Instructions for using Mythril are found on the [Wiki](https://github.com/ConsenSys/mythril/wiki). 
 
 For support or general discussions please join the Mythril community on [Discord](https://discord.gg/E3YrVtG).
 
 ## Bulding the Documentation
-Mythril Classic's documentation is contained in the `docs` folder and is published to [Read the Docs](https://mythril-classic.readthedocs.io/en/master/). It is based on Sphinx and can be built using the Makefile contained in the subdirectory:
+Mythril's documentation is contained in the `docs` folder and is published to [Read the Docs](https://mythril.readthedocs.io/en/master/). It is based on Sphinx and can be built using the Makefile contained in the subdirectory:
 
 ```
 cd docs

docs/source/conf.py

@@ -20,14 +20,14 @@ sys.path.insert(0, os.path.abspath("../../"))
 
 # -- Project information -----------------------------------------------------
 
-project = "Mythril Classic"
-copyright = "2018, Bernhard Mueller"
-author = "Bernhard Mueller"
+project = "Mythril"
+copyright = "2019, ConsenSys Diligence"
+author = "ConsenSys Dilligence"
 
 # The short X.Y version
 version = ""
 # The full version, including alpha/beta/rc tags
-from mythril.version import VERSION
+from mythril.__version__ import __version__ as VERSION
 
 release = VERSION
 

docs/source/module-list.rst

@@ -35,7 +35,7 @@ The `exceptions module <https://github.com/ConsenSys/mythril-classic/blob/develo
 External Calls
 **************
 
-The `external calls module <https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/analysis/modules/external_calls.py>`_ detects `SWC-117 (Reentrancy) <https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-117>`_ by detecting state changes after calls to external contracts.
+The `external calls module <https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/analysis/modules/external_calls.py>`_ warns about `SWC-117 (Reentrancy) <https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-107>`_ by detecting calls to external contracts.
 
 *******
 Integer
@@ -55,11 +55,12 @@ Suicide
 
 The `suicide module <https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/analysis/modules/suicide.py>`_ detects `SWC-106 (Unprotected SELFDESTRUCT) <https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-106>`_.
 
+
 ****************************
-Transaction Order Dependence
+State Change External Calls
 ****************************
 
-The `transaction order dependence module <https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/analysis/modules/transaction_order_dependence.py>`_ detects `SWC-114 (Transaction Order Dependence / Race Conditions) <https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-114>`_.
+The `state change external calls module <https://github.com/ConsenSys/mythril-classic/blob/develop/mythril/analysis/modules/state_change_external_calls.py>`_ detects `SWC-107 (Reentrancy) <https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-107>`_ by detecting state change after calls to an external contract.
 
 ****************
 Unchecked Retval

mythril/__init__.py

@@ -3,4 +3,4 @@
 __docformat__ = "restructuredtext"
 
 # Accept mythril.VERSION to get mythril's current version number
-from .version import VERSION  # NOQA
+from .__version__ import __version__ as VERSION  # NOQA

mythril/__version__.py

@@ -4,4 +4,4 @@ This file is suitable for sourcing inside POSIX shell, e.g. bash as well
 as for importing into Python.
 """
 
-VERSION = "v0.20.4"  # NOQA
+__version__ = "v0.20.8"

mythril/analysis/callgraph.py

@@ -125,7 +125,7 @@ phrack_color = {
 }
 
 
-def extract_nodes(statespace, color_map):
+def extract_nodes(statespace):
     """
 
     :param statespace:
@@ -133,6 +133,7 @@ def extract_nodes(statespace, color_map):
     :return:
     """
     nodes = []
+    color_map = {}
     for node_key in statespace.nodes:
         node = statespace.nodes[node_key]
         instructions = [state.get_current_instruction() for state in node.states]
@@ -164,10 +165,16 @@ def extract_nodes(statespace, color_map):
             else "\n".join(code_split[:6]) + "\n(click to expand +)"
         )
 
+        if node.get_cfg_dict()["contract_name"] not in color_map.keys():
+            color = default_colors[len(color_map) % len(default_colors)]
+            color_map[node.get_cfg_dict()["contract_name"]] = color
+
         nodes.append(
             {
                 "id": str(node_key),
-                "color": color_map[node.get_cfg_dict()["contract_name"]],
+                "color": color_map.get(
+                    node.get_cfg_dict()["contract_name"], default_colors[0]
+                ),
                 "size": 150,
                 "fullLabel": "\n".join(code_split),
                 "label": truncated_code,
@@ -231,22 +238,12 @@ def generate_graph(
     template = env.get_template("callgraph.html")
 
     graph_opts = default_opts
-    accounts = statespace.accounts
-
-    if phrackify:
-        color_map = {accounts[k].contract_name: phrack_color for k in accounts}
-        graph_opts.update(phrack_opts)
-    else:
-        color_map = {
-            accounts[k].contract_name: default_colors[i % len(default_colors)]
-            for i, k in enumerate(accounts)
-        }
 
     graph_opts["physics"]["enabled"] = physics
 
     return template.render(
         title=title,
-        nodes=extract_nodes(statespace, color_map),
+        nodes=extract_nodes(statespace),
         edges=extract_edges(statespace),
         phrackify=phrackify,
         opts=graph_opts,

mythril/analysis/modules/base.py

@@ -49,12 +49,26 @@ class DetectionModule:
         """
         self._issues = []
 
-    def execute(self, statespace):
+    def execute(self, statespace) -> None:
         """The entry point for execution, which is being called by Mythril.
 
         :param statespace:
         :return:
         """
+
+        log.debug("Entering analysis module: {}".format(self.__class__.__name__))
+
+        self._execute(statespace)
+
+        log.debug("Exiting analysis module: {}".format(self.__class__.__name__))
+
+    def _execute(self, statespace):
+        """Module main method (override this)
+
+        :param statespace:
+        :return:
+        """
+
         raise NotImplementedError()
 
     def __repr__(self) -> str:

mythril/analysis/modules/delegatecall.py

@@ -1,19 +1,71 @@
 """This module contains the detection code for insecure delegate call usage."""
-import re
+import json
 import logging
-from typing import List
+from copy import copy
+from typing import List, cast
 
+from mythril.analysis import solver
 from mythril.analysis.swc_data import DELEGATECALL_TO_UNTRUSTED_CONTRACT
-from mythril.analysis.ops import get_variable, VarType, Call, Variable
 from mythril.analysis.report import Issue
-from mythril.analysis.call_helpers import get_call_from_state
 from mythril.analysis.modules.base import DetectionModule
+from mythril.exceptions import UnsatError
+from mythril.laser.ethereum.state.annotation import StateAnnotation
 from mythril.laser.ethereum.state.global_state import GlobalState
-
+from mythril.laser.smt import symbol_factory, UGT
 
 log = logging.getLogger(__name__)
 
 
+class DelegateCallAnnotation(StateAnnotation):
+    def __init__(self, call_state: GlobalState) -> None:
+        """
+        Initialize DelegateCall Annotation
+        :param call_state: Call state
+        """
+        self.call_state = call_state
+        self.return_value = call_state.new_bitvec(
+            "retval_{}".format(call_state.get_current_instruction()["address"]), 256
+        )
+
+    def get_issue(self, global_state: GlobalState, transaction_sequence: str) -> Issue:
+        """
+        Returns Issue for the annotation
+        :param global_state: Global State
+        :param transaction_sequence: Transaction sequence
+        :return: Issue
+        """
+
+        address = self.call_state.get_current_instruction()["address"]
+        logging.debug(
+            "[DELEGATECALL] Detected delegatecall to a user-supplied address : {}".format(
+                address
+            )
+        )
+        description_head = "The contract delegates execution to another contract with a user-supplied address."
+        description_tail = (
+            "The smart contract delegates execution to a user-supplied address. Note that callers "
+            "can execute arbitrary contracts and that the callee contract "
+            "can access the storage of the calling contract. "
+        )
+
+        return Issue(
+            contract=self.call_state.environment.active_account.contract_name,
+            function_name=self.call_state.environment.active_function_name,
+            address=address,
+            swc_id=DELEGATECALL_TO_UNTRUSTED_CONTRACT,
+            title="Delegatecall Proxy To User-Supplied Address",
+            bytecode=global_state.environment.code.bytecode,
+            severity="Medium",
+            description_head=description_head,
+            description_tail=description_tail,
+            debug=transaction_sequence,
+            gas_used=(
+                global_state.mstate.min_gas_used,
+                global_state.mstate.max_gas_used,
+            ),
+        )
+
+
 class DelegateCallModule(DetectionModule):
     """This module detects calldata being forwarded using DELEGATECALL."""
 
@@ -24,18 +76,16 @@ class DelegateCallModule(DetectionModule):
             swc_id=DELEGATECALL_TO_UNTRUSTED_CONTRACT,
             description="Check for invocations of delegatecall(msg.data) in the fallback function.",
             entrypoint="callback",
-            pre_hooks=["DELEGATECALL"],
+            pre_hooks=["DELEGATECALL", "RETURN", "STOP"],
         )
 
-    def execute(self, state: GlobalState) -> list:
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
-        log.debug("Executing module: DELEGATE_CALL")
         self._issues.extend(_analyze_states(state))
-        return self.issues
 
 
 def _analyze_states(state: GlobalState) -> List[Issue]:
@@ -43,59 +93,47 @@ def _analyze_states(state: GlobalState) -> List[Issue]:
     :param state: the current state
     :return: returns the issues for that corresponding state
     """
-    call = get_call_from_state(state)
-    if call is None:
-        return []
-    issues = []  # type: List[Issue]
+    issues = []
+    op_code = state.get_current_instruction()["opcode"]
+    annotations = cast(
+        List[DelegateCallAnnotation],
+        list(state.get_annotations(DelegateCallAnnotation)),
+    )
 
-    if call.type is not "DELEGATECALL":
-        return []
-    if state.environment.active_function_name is not "fallback":
+    if len(annotations) == 0 and op_code in ("RETURN", "STOP"):
         return []
 
-    state = call.state
-    address = state.get_current_instruction()["address"]
-    meminstart = get_variable(state.mstate.stack[-3])
+    if op_code == "DELEGATECALL":
+        gas = state.mstate.stack[-1]
+        to = state.mstate.stack[-2]
 
-    if meminstart.type == VarType.CONCRETE:
-        issues += _concrete_call(call, state, address, meminstart)
+        constraints = copy(state.mstate.constraints)
+        # Check whether we can also set the callee address
 
-    return issues
+        constraints += [
+            to == 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF,
+            UGT(gas, symbol_factory.BitVecVal(2300, 256)),
+        ]
+        try:
+            solver.get_model(constraints)
+            state.annotate(DelegateCallAnnotation(call_state=state))
 
+        except UnsatError:
+            log.debug("[DELEGATECALL] Annotation skipped.")
 
-def _concrete_call(
-    call: Call, state: GlobalState, address: int, meminstart: Variable
-) -> List[Issue]:
-    """
-    :param call: The current call's information
-    :param state: The current state
-    :param address: The PC address
-    :param meminstart: memory starting position
-    :return: issues
-    """
-    if not re.search(r"calldata.*\[0", str(state.mstate.memory[meminstart.val])):
         return []
-
-    issue = Issue(
-        contract=state.environment.active_account.contract_name,
-        function_name=state.environment.active_function_name,
-        address=address,
-        swc_id=DELEGATECALL_TO_UNTRUSTED_CONTRACT,
-        bytecode=state.environment.code.bytecode,
-        title="Delegatecall Proxy",
-        severity="Low",
-        description_head="The contract implements a delegatecall proxy.",
-        description_tail="The smart contract forwards the received calldata via delegatecall. Note that callers "
-        "can execute arbitrary functions in the callee contract and that the callee contract "
-        "can access the storage of the calling contract. "
-        "Make sure that the callee contract is audited properly.",
-        gas_used=(state.mstate.min_gas_used, state.mstate.max_gas_used),
-    )
-
-    target = hex(call.to.val) if call.to.type == VarType.CONCRETE else str(call.to)
-    issue.description += "DELEGATECALL target: {}".format(target)
-
-    return [issue]
+    else:
+        for annotation in annotations:
+            try:
+                transaction_sequence = solver.get_transaction_sequence(
+                    state, state.mstate.constraints + [annotation.return_value == 1]
+                )
+                debug = json.dumps(transaction_sequence, indent=4)
+                issues.append(annotation.get_issue(state, transaction_sequence=debug))
+            except UnsatError:
+                continue
+
+        return issues
 
 
 detector = DelegateCallModule()

mythril/analysis/modules/dependence_on_predictable_vars.py

@@ -1,22 +1,53 @@
 """This module contains the detection code for predictable variable
 dependence."""
 import logging
-import re
 
-from mythril.analysis import solver
-from mythril.analysis.call_helpers import get_call_from_state
 from mythril.analysis.modules.base import DetectionModule
-from mythril.analysis.ops import Call, VarType
 from mythril.analysis.report import Issue
-from mythril.analysis.swc_data import TIMESTAMP_DEPENDENCE, WEAK_RANDOMNESS
 from mythril.exceptions import UnsatError
+from mythril.analysis import solver
+from mythril.laser.smt import ULT, symbol_factory
+from mythril.analysis.swc_data import TIMESTAMP_DEPENDENCE, WEAK_RANDOMNESS
 from mythril.laser.ethereum.state.global_state import GlobalState
+from mythril.laser.ethereum.state.annotation import StateAnnotation
+from typing import cast, List
+import traceback
 
 log = logging.getLogger(__name__)
 
+predictable_ops = ["COINBASE", "GASLIMIT", "TIMESTAMP", "NUMBER"]
+final_ops = ["CALL", "SUICIDE", "STOP", "RETURN"]
+
+
+def is_prehook() -> bool:
+    """Check if we are in prehook.  One of Bernhard's trademark hacks!"""
+    return "pre_hook" in traceback.format_stack()[-5]
+
+
+class PredictableValueAnnotation:
+    """Symbol annotation used if a variable is initialized from a predictable environment variable."""
+
+    def __init__(self, operation: str) -> None:
+        self.operation = operation
+
+
+class PredictablePathAnnotation(StateAnnotation):
+    """State annotation used when a path is chosen based on a predictable variable."""
+
+    def __init__(self, operation: str, location: int) -> None:
+        self.operation = operation
+        self.location = location
+
+
+class OldBlockNumberUsedAnnotation(StateAnnotation):
+    """State annotation set in blockhash prehook if the input value is lower than the current block number."""
+
+    def __init__(self) -> None:
+        pass
+
 
 class PredictableDependenceModule(DetectionModule):
-    """This module detects whether Ether is sent using predictable
+    """This module detects whether control flow decisions are made using predictable
     parameters."""
 
     def __init__(self) -> None:
@@ -25,26 +56,22 @@ class PredictableDependenceModule(DetectionModule):
             name="Dependence of Predictable Variables",
             swc_id="{} {}".format(TIMESTAMP_DEPENDENCE, WEAK_RANDOMNESS),
             description=(
-                "Check for CALLs that send >0 Ether as a result of computation "
-                "based on predictable variables such as block.coinbase, "
-                "block.gaslimit, block.timestamp, block.number"
+                "Check whether important control flow decisions are influenced by block.coinbase,"
+                "block.gaslimit, block.timestamp or block.number."
             ),
             entrypoint="callback",
-            pre_hooks=["CALL", "CALLCODE", "DELEGATECALL", "STATICCALL"],
+            pre_hooks=["BLOCKHASH", "JUMPI"] + final_ops,
+            post_hooks=["BLOCKHASH"] + predictable_ops,
         )
 
-    def execute(self, state: GlobalState) -> list:
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
-        log.debug("Executing module: DEPENDENCE_ON_PREDICTABLE_VARS")
-        self._issues.extend(_analyze_states(state))
-        return self.issues
-
 
-detector = PredictableDependenceModule()
+        self._issues.extend(_analyze_states(state))
 
 
 def _analyze_states(state: GlobalState) -> list:
@@ -53,172 +80,125 @@ def _analyze_states(state: GlobalState) -> list:
     :param state:
     :return:
     """
+
     issues = []
-    call = get_call_from_state(state)
-    if call is None:
-        return []
-    if "callvalue" in str(call.value):
-        log.debug("[DEPENDENCE_ON_PREDICTABLE_VARS] Skipping refund function")
-        return []
-
-    # We're only interested in calls that send Ether
-    if call.value.type == VarType.CONCRETE and call.value.val == 0:
-        return []
-
-    address = call.state.get_current_instruction()["address"]
-
-    description = (
-        "The contract sends Ether depending on the values of the following variables:\n"
-    )
-
-    # First check: look for predictable state variables in state & call recipient constraints
-
-    vars = ["coinbase", "gaslimit", "timestamp", "number"]
-    found = []
-
-    for var in vars:
-        for constraint in call.state.mstate.constraints[:] + [call.to]:
-            if var in str(constraint):
-                found.append(var)
-
-    if len(found):
-        for item in found:
-            description += "- block.{}\n".format(item)
-        if solve(call):
-            swc_id = TIMESTAMP_DEPENDENCE if item == "timestamp" else WEAK_RANDOMNESS
-
-            description += (
-                "Note that the values of variables like coinbase, gaslimit, block number and timestamp "
-                "are predictable and/or can be manipulated by a malicious miner. "
-                "Don't use them for random number generation or to make critical decisions."
-            )
 
-            issue = Issue(
-                contract=state.environment.active_account.contract_name,
-                function_name=state.environment.active_function_name,
-                address=address,
-                swc_id=swc_id,
-                bytecode=call.state.environment.code.bytecode,
-                title="Dependence on predictable environment variable",
-                severity="Low",
-                description_head="Sending of Ether depends on a predictable variable.",
-                description_tail=description,
-                gas_used=(
-                    call.state.mstate.min_gas_used,
-                    call.state.mstate.max_gas_used,
-                ),
-            )
-            issues.append(issue)
+    if is_prehook():
 
-    # Second check: blockhash
+        opcode = state.get_current_instruction()["opcode"]
 
-    for constraint in call.state.mstate.constraints[:] + [call.to]:
-        if "blockhash" in str(constraint):
-            if "number" in str(constraint):
-                m = re.search(r"blockhash\w+(\s-\s(\d+))*", str(constraint))
-                if m and solve(call):
+        if opcode in final_ops:
 
-                    found_item = m.group(1)
+            for annotation in state.annotations:
 
-                    if found_item:  # block.blockhash(block.number - N)
-                        description = (
-                            "The predictable expression 'block.blockhash(block.number - "
-                            + m.group(2)
-                            + ")' is used to determine Ether recipient"
-                        )
-                        if int(m.group(2)) > 255:
-                            description += (
-                                ", this expression will always be equal to zero."
-                            )
-                    elif "storage" in str(
-                        constraint
-                    ):  # block.blockhash(block.number - storage_0)
-                        description = (
-                            "The predictable expression 'block.blockhash(block.number - "
-                            + "some_storage_var)' is used to determine Ether recipient"
-                        )
-                    else:  # block.blockhash(block.number)
-                        description = (
-                            "The predictable expression 'block.blockhash(block.number)'"
-                            + " is used to determine Ether recipient"
-                        )
-                        description += ", this expression will always be equal to zero."
+                if isinstance(annotation, PredictablePathAnnotation):
+                    description = (
+                        "The "
+                        + annotation.operation
+                        + " is used in to determine a control flow decision. "
+                    )
+                    description += (
+                        "Note that the values of variables like coinbase, gaslimit, block number and timestamp "
+                        "are predictable and can be manipulated by a malicious miner. Also keep in mind that attackers "
+                        "know hashes of earlier blocks. Don't use any of those environment variables for random number "
+                        "generation or to make critical control flow decisions."
+                    )
+
+                    """
+                    Usually report low severity except in cases where the hash of a previous block is used to
+                    determine control flow. 
+                    """
+
+                    severity = "Medium" if "hash" in annotation.operation else "Low"
+
+                    """
+                    Note: We report the location of the JUMPI that lead to this path. Usually this maps to an if or
+                    require statement.
+                    """
+
+                    swc_id = (
+                        TIMESTAMP_DEPENDENCE
+                        if "timestamp" in annotation.operation
+                        else WEAK_RANDOMNESS
+                    )
 
                     issue = Issue(
                         contract=state.environment.active_account.contract_name,
                         function_name=state.environment.active_function_name,
-                        address=address,
-                        bytecode=call.state.environment.code.bytecode,
-                        title="Dependence on Predictable Variable",
-                        severity="Low",
-                        description_head="Sending of Ether depends on the blockhash.",
+                        address=annotation.location,
+                        swc_id=swc_id,
+                        bytecode=state.environment.code.bytecode,
+                        title="Dependence on predictable environment variable",
+                        severity=severity,
+                        description_head="A control flow decision is made based on a predictable variable.",
                         description_tail=description,
-                        swc_id=WEAK_RANDOMNESS,
-                        gas_used=(
-                            call.state.mstate.min_gas_used,
-                            call.state.mstate.max_gas_used,
-                        ),
+                        gas_used=(state.mstate.min_gas_used, state.mstate.max_gas_used),
                     )
                     issues.append(issue)
-                    break
-            else:
 
-                r = re.search(r"storage_([a-z0-9_&^]+)", str(constraint))
-                if r:  # block.blockhash(storage_0)
+        elif opcode == "JUMPI":
 
-                    """We actually can do better here by adding a constraint
-                    blockhash_block_storage_0 == 0 and checking model
-                    satisfiability.
+            # Look for predictable state variables in jump condition
 
-                    When this is done, severity can be raised from
-                    'Informational' to 'Warning'. Checking that storage
-                    at given index can be tainted is not necessary,
-                    since it usually contains block.number of the
-                    'commit' transaction in commit-reveal workflow.
-                    """
+            for annotation in state.mstate.stack[-2].annotations:
 
-                    index = r.group(1)
-                    if index and solve(call):
-                        description = (
-                            "A block hash is calculated using the block.blockhash(uint blockNumber) method. "
-                            "The block number is obtained from storage index {}".format(
-                                index
-                            )
+                if isinstance(annotation, PredictableValueAnnotation):
+                    state.annotate(
+                        PredictablePathAnnotation(
+                            annotation.operation,
+                            state.get_current_instruction()["address"],
                         )
-                        issue = Issue(
-                            contract=state.environment.active_account.contract_name,
-                            function_name=state.environment.active_function_name,
-                            address=address,
-                            bytecode=call.state.environment.code.bytecode,
-                            title="Dependence on Predictable Variable",
-                            severity="Low",
-                            description_head="Sending of Ether depends on the blockhash.",
-                            description_tail=description,
-                            swc_id=WEAK_RANDOMNESS,
-                            gas_used=(
-                                call.state.mstate.min_gas_used,
-                                call.state.mstate.max_gas_used,
-                            ),
-                        )
-                        issues.append(issue)
-                        break
-    return issues
+                    )
+                    break
 
+        elif opcode == "BLOCKHASH":
 
-def solve(call: Call) -> bool:
-    """
+            param = state.mstate.stack[-1]
 
-    :param call:
-    :return:
-    """
-    try:
-        model = solver.get_model(call.state.mstate.constraints)
-        log.debug("[DEPENDENCE_ON_PREDICTABLE_VARS] MODEL: " + str(model))
-        pretty_model = solver.pretty_print_model(model)
+            try:
+                constraint = [
+                    ULT(param, state.environment.block_number),
+                    ULT(
+                        state.environment.block_number,
+                        symbol_factory.BitVecVal(2 ** 255, 256),
+                    ),
+                ]
+
+                # Why the second constraint? Because without it Z3 returns a solution where param overflows.
+
+                solver.get_model(constraint)
+                state.annotate(OldBlockNumberUsedAnnotation())
 
-        log.debug("[DEPENDENCE_ON_PREDICTABLE_VARS] main model: \n%s" % pretty_model)
-        return True
+            except UnsatError:
+                pass
 
-    except UnsatError:
-        log.debug("[DEPENDENCE_ON_PREDICTABLE_VARS] no model found")
-        return False
+    else:
+        # we're in post hook
+
+        opcode = state.environment.code.instruction_list[state.mstate.pc - 1]["opcode"]
+
+        if opcode == "BLOCKHASH":
+            # if we're in the post hook of a BLOCKHASH op, check if an old block number was used to create it.
+
+            annotations = cast(
+                List[OldBlockNumberUsedAnnotation],
+                list(state.get_annotations(OldBlockNumberUsedAnnotation)),
+            )
+
+            if len(annotations):
+                state.mstate.stack[-1].annotate(
+                    PredictableValueAnnotation("block hash of a previous block")
+                )
+        else:
+            # Always create an annotation when COINBASE, GASLIMIT, TIMESTAMP or NUMBER is executed.
+
+            state.mstate.stack[-1].annotate(
+                PredictableValueAnnotation(
+                    "block.{} environment variable".format(opcode.lower())
+                )
+            )
+
+    return issues
+
+
+detector = PredictableDependenceModule()

mythril/analysis/modules/deprecated_ops.py

@@ -76,14 +76,13 @@ class DeprecatedOperationsModule(DetectionModule):
             pre_hooks=["ORIGIN", "CALLCODE"],
         )
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(_analyze_state(state))
-        return self.issues
 
 
 detector = DeprecatedOperationsModule()

mythril/analysis/modules/dos.py

@@ -0,0 +1,127 @@
+"""This module contains the detection code SWC-128 - DOS with block gas limit."""
+
+import logging
+from typing import Dict, cast, List
+
+from mythril.analysis.swc_data import DOS_WITH_BLOCK_GAS_LIMIT
+from mythril.analysis.report import Issue
+from mythril.analysis.modules.base import DetectionModule
+from mythril.laser.ethereum.state.global_state import GlobalState
+from mythril.laser.ethereum.state.annotation import StateAnnotation
+from mythril.laser.ethereum import util
+
+log = logging.getLogger(__name__)
+
+
+class LoopAnnotation(StateAnnotation):
+    def __init__(self, loop_start: int, loop_end: int) -> None:
+        self.loop_start = loop_start
+        self.loop_end = loop_end
+
+    def contains(self, address: int) -> bool:
+        return self.loop_start < address < self.loop_end
+
+
+class DOS(DetectionModule):
+    """This module consists of a makeshift loop detector that annotates the state with
+    a list of byte ranges likely to be loops. If a CALL or SSTORE detection is found in
+    one of the ranges it creates a low-severity issue. This is not super precise but
+    good enough to identify places that warrant a closer look. Checking the loop condition
+    would be a possible improvement.
+     """
+
+    def __init__(self) -> None:
+        """"""
+        super().__init__(
+            name="DOS",
+            swc_id=DOS_WITH_BLOCK_GAS_LIMIT,
+            description="Check for DOS",
+            entrypoint="callback",
+            pre_hooks=["JUMPI", "CALL", "SSTORE"],
+        )
+
+        """Keeps track of how often jump destinations are reached."""
+        self._jumpdest_count = {}  # type: Dict[object, dict]
+
+    def _execute(self, state: GlobalState) -> None:
+        """
+
+        :param state:
+        :return:
+        """
+
+        self._issues.extend(self._analyze_states(state))
+
+    def _analyze_states(self, state: GlobalState) -> List[Issue]:
+        """
+        :param state: the current state
+        :return: returns the issues for that corresponding state
+        """
+
+        opcode = state.get_current_instruction()["opcode"]
+        address = state.get_current_instruction()["address"]
+
+        if opcode == "JUMPI":
+
+            target = util.get_concrete_int(state.mstate.stack[-1])
+
+            transaction = state.current_transaction
+            if state.current_transaction in self._jumpdest_count:
+
+                try:
+                    self._jumpdest_count[transaction][target] += 1
+                    if self._jumpdest_count[transaction][target] == 4:
+
+                        annotation = (
+                            LoopAnnotation(address, target)
+                            if target > address
+                            else LoopAnnotation(target, address)
+                        )
+
+                        state.annotate(annotation)
+                except KeyError:
+                    self._jumpdest_count[transaction][target] = 0
+
+            else:
+                self._jumpdest_count[transaction] = {}
+                self._jumpdest_count[transaction][target] = 0
+
+        else:
+
+            annotations = cast(
+                List[LoopAnnotation], list(state.get_annotations(LoopAnnotation))
+            )
+
+            for annotation in annotations:
+
+                if annotation.contains(address):
+
+                    operation = (
+                        "A storage modification"
+                        if opcode == "SSTORE"
+                        else "An external call"
+                    )
+
+                    description_head = (
+                        "Potential denial-of-service if block gas limit is reached."
+                    )
+                    description_tail = "{} is executed in a loop.".format(operation)
+
+                    issue = Issue(
+                        contract=state.environment.active_account.contract_name,
+                        function_name=state.environment.active_function_name,
+                        address=annotation.loop_start,
+                        swc_id=DOS_WITH_BLOCK_GAS_LIMIT,
+                        bytecode=state.environment.code.bytecode,
+                        title="Potential denial-of-service if block gas limit is reached",
+                        severity="Low",
+                        description_head=description_head,
+                        description_tail=description_tail,
+                        gas_used=(state.mstate.min_gas_used, state.mstate.max_gas_used),
+                    )
+                    return [issue]
+
+        return []
+
+
+detector = DOS()

mythril/analysis/modules/ether_thief.py

@@ -7,6 +7,7 @@ from copy import copy
 from mythril.analysis import solver
 from mythril.analysis.modules.base import DetectionModule
 from mythril.analysis.report import Issue
+from mythril.laser.ethereum.transaction.symbolic import ATTACKER_ADDRESS
 from mythril.analysis.swc_data import UNPROTECTED_ETHER_WITHDRAWAL
 from mythril.exceptions import UnsatError
 from mythril.laser.ethereum.state.global_state import GlobalState
@@ -51,14 +52,13 @@ class EtherThief(DetectionModule):
         super().reset_module()
         self._cache_addresses = {}
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(self._analyze_state(state))
-        return self.issues
 
     def _analyze_state(self, state):
         """
@@ -82,15 +82,13 @@ class EtherThief(DetectionModule):
         constraints = copy(state.mstate.constraints)
 
         for tx in state.world_state.transaction_sequence:
-            if tx.caller == 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF:
-                # There's sometimes no overflow check on balances added.
-                # But we don't care about attacks that require more 2^^256 ETH to be sent.
+            constraints += [BVAddNoOverflow(eth_sent_total, tx.call_value, False)]
+            eth_sent_total = Sum(eth_sent_total, tx.call_value)
 
-                constraints += [BVAddNoOverflow(eth_sent_total, tx.call_value, False)]
-                eth_sent_total = Sum(eth_sent_total, tx.call_value)
         constraints += [
+            tx.caller == ATTACKER_ADDRESS,
             UGT(call_value, eth_sent_total),
-            target == state.environment.sender,
+            target == ATTACKER_ADDRESS,
         ]
 
         try:

mythril/analysis/modules/exceptions.py

@@ -72,14 +72,13 @@ class ReachableExceptionsModule(DetectionModule):
             pre_hooks=["ASSERT_FAIL"],
         )
 
-    def execute(self, state: GlobalState) -> list:
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(_analyze_state(state))
-        return self.issues
 
 
 detector = ReachableExceptionsModule()

mythril/analysis/modules/external_calls.py

@@ -5,7 +5,7 @@ from mythril.analysis import solver
 from mythril.analysis.swc_data import REENTRANCY
 from mythril.analysis.modules.base import DetectionModule
 from mythril.analysis.report import Issue
-from mythril.laser.smt import UGT, symbol_factory
+from mythril.laser.smt import UGT, symbol_factory, Or, BitVec
 from mythril.laser.ethereum.state.global_state import GlobalState
 from mythril.exceptions import UnsatError
 from copy import copy
@@ -71,6 +71,8 @@ def _analyze_state(state):
             )
 
         except UnsatError:
+            if _is_precompile_call(state):
+                return []
 
             log.debug(
                 "[EXTERNAL_CALLS] Callee address cannot be modified. Reporting informational issue."
@@ -104,6 +106,23 @@ def _analyze_state(state):
     return [issue]
 
 
+def _is_precompile_call(global_state: GlobalState):
+    to = global_state.mstate.stack[-2]  # type: BitVec
+    constraints = copy(global_state.mstate.constraints)
+    constraints += [
+        Or(
+            to < symbol_factory.BitVecVal(1, 256),
+            to > symbol_factory.BitVecVal(16, 256),
+        )
+    ]
+
+    try:
+        solver.get_model(constraints)
+        return False
+    except UnsatError:
+        return True
+
+
 class ExternalCalls(DetectionModule):
     """This module searches for low level calls (e.g. call.value()) that
     forward all gas to the callee."""
@@ -118,14 +137,13 @@ class ExternalCalls(DetectionModule):
             pre_hooks=["CALL"],
         )
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(_analyze_state(state))
-        return self.issues
 
 
 detector = ExternalCalls()

mythril/analysis/modules/integer.py

@@ -84,7 +84,7 @@ class IntegerOverflowUnderflowModule(DetectionModule):
         self._overflow_cache = {}
         self._underflow_cache = {}
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         """Executes analysis module for integer underflow and integer overflow.
 
         :param state: Statespace to analyse

mythril/analysis/modules/multiple_sends.py

@@ -1,27 +1,25 @@
 """This module contains the detection code to find multiple sends occurring in
 a single transaction."""
 from copy import copy
-from typing import cast, List, Optional
+from typing import cast, List
 
-from mythril.analysis.ops import Call
 from mythril.analysis.report import Issue
 from mythril.analysis.swc_data import MULTIPLE_SENDS
 from mythril.analysis.modules.base import DetectionModule
 from mythril.laser.ethereum.state.annotation import StateAnnotation
 from mythril.laser.ethereum.state.global_state import GlobalState
 import logging
-from mythril.analysis.call_helpers import get_call_from_state
 
 log = logging.getLogger(__name__)
 
 
 class MultipleSendsAnnotation(StateAnnotation):
     def __init__(self) -> None:
-        self.calls = []  # type: List[Optional[Call]]
+        self.call_offsets = []  # type: List[int]
 
     def __copy__(self):
         result = MultipleSendsAnnotation()
-        result.calls = copy(self.calls)
+        result.call_offsets = copy(self.call_offsets)
         return result
 
 
@@ -45,9 +43,8 @@ class MultipleSendsModule(DetectionModule):
             ],
         )
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         self._issues.extend(_analyze_state(state))
-        return self.issues
 
 
 def _analyze_state(state: GlobalState):
@@ -62,46 +59,35 @@ def _analyze_state(state: GlobalState):
         list(state.get_annotations(MultipleSendsAnnotation)),
     )
     if len(annotations) == 0:
-        log.debug("Creating annotation for state")
         state.annotate(MultipleSendsAnnotation())
         annotations = cast(
             List[MultipleSendsAnnotation],
             list(state.get_annotations(MultipleSendsAnnotation)),
         )
 
-    calls = annotations[0].calls
+    call_offsets = annotations[0].call_offsets
 
     if instruction["opcode"] in ["CALL", "DELEGATECALL", "STATICCALL", "CALLCODE"]:
-        call = get_call_from_state(state)
-        if call:
-            calls += [call]
+        call_offsets.append(state.get_current_instruction()["address"])
 
     else:  # RETURN or STOP
-        if len(calls) > 1:
 
-            description_tail = (
-                "Consecutive calls are executed at the following bytecode offsets:\n"
-            )
+        for offset in call_offsets[1:]:
 
-            for call in calls:
-                description_tail += "Offset: {}\n".format(
-                    call.state.get_current_instruction()["address"]
-                )
-
-            description_tail += (
-                "Try to isolate each external call into its own transaction,"
-                " as external calls can fail accidentally or deliberately.\n"
+            description_tail = (
+                "This call is executed after a previous call in the same transaction. "
+                "Try to isolate each call, transfer or send into its own transaction."
             )
 
             issue = Issue(
                 contract=state.environment.active_account.contract_name,
                 function_name=state.environment.active_function_name,
-                address=instruction["address"],
+                address=offset,
                 swc_id=MULTIPLE_SENDS,
                 bytecode=state.environment.code.bytecode,
                 title="Multiple Calls in a Single Transaction",
-                severity="Medium",
-                description_head="Multiple sends are executed in one transaction.",
+                severity="Low",
+                description_head="Multiple calls are executed in the same transaction.",
                 description_tail=description_tail,
                 gas_used=(state.mstate.min_gas_used, state.mstate.max_gas_used),
             )

mythril/analysis/modules/state_change_external_calls.py

@@ -84,9 +84,8 @@ class StateChange(DetectionModule):
             ],
         )
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         self._issues.extend(self._analyze_state(state))
-        return self.issues
 
     @staticmethod
     def _add_external_call(global_state: GlobalState) -> None:

mythril/analysis/modules/suicide.py

@@ -37,14 +37,13 @@ class SuicideModule(DetectionModule):
         super().reset_module()
         self._cache_address = {}
 
-    def execute(self, state: GlobalState):
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(self._analyze_state(state))
-        return self.issues
 
     def _analyze_state(self, state):
         log.info("Suicide module: Analyzing suicide instruction")

mythril/analysis/modules/unchecked_retval.py

@@ -49,14 +49,13 @@ class UncheckedRetvalModule(DetectionModule):
             post_hooks=["CALL", "DELEGATECALL", "STATICCALL", "CALLCODE"],
         )
 
-    def execute(self, state: GlobalState) -> list:
+    def _execute(self, state: GlobalState) -> None:
         """
 
         :param state:
         :return:
         """
         self._issues.extend(_analyze_state(state))
-        return self.issues
 
 
 def _analyze_state(state: GlobalState) -> list:

mythril/analysis/security.py

@@ -52,6 +52,10 @@ def get_detection_modules(entrypoint, include_modules=()):
     :param include_modules:
     :return:
     """
+
+    module = importlib.import_module("mythril.analysis.modules.base")
+    module.log.setLevel(log.level)
+
     include_modules = list(include_modules)
 
     _modules = []
@@ -62,12 +66,14 @@ def get_detection_modules(entrypoint, include_modules=()):
                 module = importlib.import_module(
                     "mythril.analysis.modules." + module_name
                 )
+                module.log.setLevel(log.level)
                 if module.detector.entrypoint == entrypoint:
                     _modules.append(module)
     else:
         for module_name in include_modules:
             module = importlib.import_module("mythril.analysis.modules." + module_name)
             if module.__name__ != "base" and module.detector.entrypoint == entrypoint:
+                module.log.setLevel(log.level)
                 _modules.append(module)
 
     log.info("Found %s detection modules", len(_modules))

mythril/analysis/symbolic.py

@@ -2,22 +2,22 @@
 purposes."""
 
 import copy
-from ethereum.utils import mk_contract_address
+
 from mythril.analysis.security import get_detection_module_hooks, get_detection_modules
 from mythril.laser.ethereum import svm
+from mythril.laser.ethereum.plugins.plugin_factory import PluginFactory
+from mythril.laser.ethereum.plugins.plugin_loader import LaserPluginLoader
 from mythril.laser.ethereum.state.account import Account
+from mythril.laser.ethereum.state.world_state import WorldState
 from mythril.laser.ethereum.strategy.basic import (
     BreadthFirstSearchStrategy,
     DepthFirstSearchStrategy,
     ReturnRandomNaivelyStrategy,
     ReturnWeightedRandomStrategy,
+    BasicSearchStrategy,
 )
-from mythril.laser.ethereum.transaction.symbolic import CREATOR_ADDRESS
-
-
-from mythril.laser.ethereum.plugins.plugin_factory import PluginFactory
-from mythril.laser.ethereum.plugins.plugin_loader import LaserPluginLoader
-
+from mythril.laser.smt import symbol_factory, BitVec
+from typing import Union, List, Dict, Type
 from mythril.solidity.soliditycontract import EVMContract, SolidityContract
 from .ops import Call, SStore, VarType, get_variable
 
@@ -32,7 +32,7 @@ class SymExecWrapper:
     def __init__(
         self,
         contract,
-        address,
+        address: Union[int, str, BitVec],
         strategy,
         dynloader=None,
         max_depth=22,
@@ -42,6 +42,7 @@ class SymExecWrapper:
         modules=(),
         compulsory_statespace=True,
         enable_iprof=False,
+        run_analysis_modules=True,
     ):
         """
 
@@ -55,8 +56,13 @@ class SymExecWrapper:
         :param transaction_count:
         :param modules:
         """
+        if isinstance(address, str):
+            address = symbol_factory.BitVecVal(int(address, 16), 256)
+        if isinstance(address, int):
+            address = symbol_factory.BitVecVal(address, 256)
+
         if strategy == "dfs":
-            s_strategy = DepthFirstSearchStrategy
+            s_strategy = DepthFirstSearchStrategy  # type: Type[BasicSearchStrategy]
         elif strategy == "bfs":
             s_strategy = BreadthFirstSearchStrategy
         elif strategy == "naive-random":
@@ -66,19 +72,11 @@ class SymExecWrapper:
         else:
             raise ValueError("Invalid strategy argument supplied")
 
-        account = Account(
-            address,
-            contract.disassembly,
-            dynamic_loader=dynloader,
-            contract_name=contract.name,
-        )
         requires_statespace = (
             compulsory_statespace or len(get_detection_modules("post", modules)) > 0
         )
-        self.accounts = {address: account}
 
         self.laser = svm.LaserEVM(
-            self.accounts,
             dynamic_loader=dynloader,
             max_depth=max_depth,
             execution_timeout=execution_timeout,
@@ -93,14 +91,15 @@ class SymExecWrapper:
         plugin_loader.load(PluginFactory.build_mutation_pruner_plugin())
         plugin_loader.load(PluginFactory.build_instruction_coverage_plugin())
 
-        self.laser.register_hooks(
-            hook_type="pre",
-            hook_dict=get_detection_module_hooks(modules, hook_type="pre"),
-        )
-        self.laser.register_hooks(
-            hook_type="post",
-            hook_dict=get_detection_module_hooks(modules, hook_type="post"),
-        )
+        if run_analysis_modules:
+            self.laser.register_hooks(
+                hook_type="pre",
+                hook_dict=get_detection_module_hooks(modules, hook_type="pre"),
+            )
+            self.laser.register_hooks(
+                hook_type="post",
+                hook_dict=get_detection_module_hooks(modules, hook_type="post"),
+            )
 
         if isinstance(contract, SolidityContract):
             self.laser.sym_exec(
@@ -111,12 +110,16 @@ class SymExecWrapper:
                 creation_code=contract.creation_code, contract_name=contract.name
             )
         else:
-            self.laser.sym_exec(address)
-        created_address = "0x" + str(mk_contract_address(CREATOR_ADDRESS, 0).hex())
-        for key, value in self.laser.world_state.accounts.items():
-            if created_address == value.address:
-                contract.code = value.code.bytecode
-                break
+            account = Account(
+                address,
+                contract.disassembly,
+                dynamic_loader=dynloader,
+                contract_name=contract.name,
+                concrete_storage=False,
+            )
+            world_state = WorldState()
+            world_state.put_account(account)
+            self.laser.sym_exec(world_state=world_state, target_address=address.value)
 
         if not requires_statespace:
             return
@@ -126,8 +129,8 @@ class SymExecWrapper:
 
         # Generate lists of interesting operations
 
-        self.calls = []
-        self.sstors = {}
+        self.calls = []  # type: List[Call]
+        self.sstors = {}  # type: Dict[int, Dict[str, List[SStore]]]
 
         for key in self.nodes:
 
@@ -204,7 +207,7 @@ class SymExecWrapper:
 
                 elif op == "SSTORE":
                     stack = copy.copy(state.mstate.stack)
-                    address = state.environment.active_account.address
+                    address = state.environment.active_account.address.value
 
                     index, value = stack.pop(), stack.pop()
 

mythril/ethereum/util.py

@@ -33,7 +33,7 @@ def get_solc_json(file, solc_binary="solc", solc_args=None):
     :return:
     """
 
-    cmd = [solc_binary, "--combined-json", "bin,bin-runtime,srcmap,srcmap-runtime"]
+    cmd = [solc_binary, "--combined-json", "bin,bin-runtime,srcmap,srcmap-runtime,ast"]
 
     if solc_args:
         cmd.extend(solc_args.split())

mythril/interfaces/cli.py

@@ -22,9 +22,7 @@ from mythril.mythril import (
     MythrilConfig,
     MythrilLevelDB,
 )
-from mythril.version import VERSION
-
-# logging.basicConfig(level=logging.DEBUG)
+from mythril.__version__ import __version__ as VERSION
 
 log = logging.getLogger(__name__)
 
@@ -216,7 +214,7 @@ def create_parser(parser: argparse.ArgumentParser) -> None:
     options.add_argument(
         "--execution-timeout",
         type=int,
-        default=600,
+        default=86400,
         help="The amount of seconds to spend on symbolic execution",
     )
     options.add_argument(

mythril/laser/ethereum/call.py

@@ -3,13 +3,12 @@ instructions.py to get the necessary elements from the stack and determine the
 parameters for the new global state."""
 
 import logging
+import re
 from typing import Union, List, cast, Callable
-from z3 import Z3Exception
-from mythril.laser.smt import BitVec
+
+import mythril.laser.ethereum.util as util
 from mythril.laser.ethereum import natives
 from mythril.laser.ethereum.gas import OPCODE_GAS
-from mythril.laser.smt import simplify, Expression, symbol_factory
-import mythril.laser.ethereum.util as util
 from mythril.laser.ethereum.state.account import Account
 from mythril.laser.ethereum.state.calldata import (
     BaseCalldata,
@@ -17,8 +16,9 @@ from mythril.laser.ethereum.state.calldata import (
     ConcreteCalldata,
 )
 from mythril.laser.ethereum.state.global_state import GlobalState
+from mythril.laser.smt import BitVec
+from mythril.laser.smt import simplify, Expression, symbol_factory
 from mythril.support.loader import DynLoader
-import re
 
 """
 This module contains the business logic used by Instruction in instructions.py
@@ -96,7 +96,7 @@ def get_callee_address(
         # attempt to read the contract address from instance storage
         try:
             callee_address = dynamic_loader.read_storage(
-                environment.active_account.address, index
+                str(hex(environment.active_account.address.value)), index
             )
         # TODO: verify whether this happens or not
         except:
@@ -124,7 +124,7 @@ def get_callee_account(
     accounts = global_state.accounts
 
     try:
-        return global_state.accounts[callee_address]
+        return global_state.accounts[int(callee_address, 16)]
     except KeyError:
         # We have a valid call address, but contract is not in the modules list
         log.debug("Module with address " + callee_address + " not loaded.")
@@ -145,7 +145,11 @@ def get_callee_account(
     log.debug("Dependency loaded: " + callee_address)
 
     callee_account = Account(
-        callee_address, code, callee_address, dynamic_loader=dynamic_loader
+        symbol_factory.BitVecVal(int(callee_address, 16), 256),
+        code,
+        callee_address,
+        dynamic_loader=dynamic_loader,
+        balances=global_state.world_state.balances,
     )
     accounts[callee_address] = callee_account
 

mythril/laser/ethereum/instructions.py

@@ -129,6 +129,8 @@ class StateTransition(object):
         min_gas, max_gas = cast(Tuple[int, int], OPCODE_GAS[opcode])
         global_state.mstate.min_gas_used += min_gas
         global_state.mstate.max_gas_used += max_gas
+        self.check_gas_usage_limit(global_state)
+
         return global_state
 
     def __call__(self, func: Callable) -> Callable:
@@ -936,9 +938,20 @@ class Instruction:
             data = symbol_factory.BitVecVal(0, 1)
 
         if data.symbolic:
+
+            annotations = []
+
+            for b in state.memory[index : index + length]:
+                if isinstance(b, BitVec):
+                    annotations.append(b.annotations)
+
             argument_str = str(state.memory[index]).replace(" ", "_")
             result = symbol_factory.BitVecFuncSym(
-                "KECCAC[{}]".format(argument_str), "keccak256", 256, input_=data
+                "KECCAC[{}]".format(argument_str),
+                "keccak256",
+                256,
+                input_=data,
+                annotations=annotations,
             )
             log.debug("Created BitVecFunc hash.")
 
@@ -959,7 +972,7 @@ class Instruction:
         :param global_state:
         :return:
         """
-        global_state.mstate.stack.append(global_state.new_bitvec("gasprice", 256))
+        global_state.mstate.stack.append(global_state.environment.gasprice)
         return [global_state]
 
     @staticmethod
@@ -1239,7 +1252,7 @@ class Instruction:
         :param global_state:
         :return:
         """
-        global_state.mstate.stack.append(global_state.new_bitvec("block_number", 256))
+        global_state.mstate.stack.append(global_state.environment.block_number)
         return [global_state]
 
     @StateTransition()
@@ -1492,7 +1505,7 @@ class Instruction:
                 global_state.environment.active_account
             )
             global_state.accounts[
-                global_state.environment.active_account.address
+                global_state.environment.active_account.address.value
             ] = global_state.environment.active_account
 
             global_state.environment.active_account.storage[index] = (
@@ -1605,7 +1618,7 @@ class Instruction:
         # Get jump destination
         index = util.get_instruction_index(disassembly.instruction_list, jump_addr)
 
-        if not index:
+        if index is None:
             log.debug("Invalid jump destination: " + str(jump_addr))
             return states
 
@@ -1634,7 +1647,12 @@ class Instruction:
         :param global_state:
         :return:
         """
-        global_state.mstate.stack.append(global_state.mstate.pc - 1)
+        index = global_state.mstate.pc
+        program_counter = global_state.environment.code.instruction_list[index][
+            "address"
+        ]
+        global_state.mstate.stack.append(program_counter)
+
         return [global_state]
 
     @StateTransition()
@@ -1644,7 +1662,7 @@ class Instruction:
         :param global_state:
         :return:
         """
-        global_state.mstate.stack.append(global_state.new_bitvec("msize", 256))
+        global_state.mstate.stack.append(global_state.mstate.memory_size)
         return [global_state]
 
     @StateTransition()
@@ -1716,8 +1734,12 @@ class Instruction:
         offset, length = state.stack.pop(), state.stack.pop()
         return_data = [global_state.new_bitvec("return_data", 8)]
         try:
+            concrete_offset = util.get_concrete_int(offset)
+            concrete_length = util.get_concrete_int(length)
+            state.mem_extend(concrete_offset, concrete_length)
+            StateTransition.check_gas_usage_limit(global_state)
             return_data = state.memory[
-                util.get_concrete_int(offset) : util.get_concrete_int(offset + length)
+                concrete_offset : concrete_offset + concrete_length
             ]
         except TypeError:
             log.debug("Return with symbolic length or offset. Not supported")
@@ -1730,31 +1752,19 @@ class Instruction:
         :param global_state:
         """
         target = global_state.mstate.stack.pop()
-        account_created = False
+        transfer_amount = global_state.environment.active_account.balance()
         # Often the target of the suicide instruction will be symbolic
-        # If it isn't then well transfer the balance to the indicated contract
-        if isinstance(target, BitVec) and not target.symbolic:
-            target = "0x" + hex(target.value)[-40:]
-        if isinstance(target, str):
-            try:
-                global_state.world_state[
-                    target
-                ].balance += global_state.environment.active_account.balance
-            except KeyError:
-                global_state.world_state.create_account(
-                    address=target,
-                    balance=global_state.environment.active_account.balance,
-                )
-                account_created = True
+        # If it isn't then we'll transfer the balance to the indicated contract
+        global_state.world_state[target].add_balance(transfer_amount)
 
         global_state.environment.active_account = deepcopy(
             global_state.environment.active_account
         )
         global_state.accounts[
-            global_state.environment.active_account.address
+            global_state.environment.active_account.address.value
         ] = global_state.environment.active_account
 
-        global_state.environment.active_account.balance = 0
+        global_state.environment.active_account.set_balance(0)
         global_state.environment.active_account.deleted = True
         global_state.current_transaction.end(global_state)
 
@@ -1839,9 +1849,7 @@ class Instruction:
             gas_price=environment.gasprice,
             gas_limit=gas,
             origin=environment.origin,
-            caller=symbol_factory.BitVecVal(
-                int(environment.active_account.address, 16), 256
-            ),
+            caller=environment.active_account.address,
             callee_account=callee_account,
             call_data=call_data,
             call_value=value,
@@ -2086,7 +2094,6 @@ class Instruction:
                 "retval_" + str(instr["address"]), 256
             )
             global_state.mstate.stack.append(return_value)
-            global_state.mstate.constraints.append(return_value == 0)
             return [global_state]
 
         try:

mythril/laser/ethereum/state/account.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, KeysView, Union
 
 from z3 import ExprRef
 
+from mythril.laser.smt import Array, symbol_factory, BitVec
 from mythril.disassembler.disassembly import Disassembly
 from mythril.laser.smt import symbol_factory
 
@@ -30,7 +31,7 @@ class Storage:
         except KeyError:
             if (
                 self.address
-                and int(self.address[2:], 16) != 0
+                and self.address.value != 0
                 and (self.dynld and self.dynld.storage_loading)
             ):
                 try:
@@ -46,9 +47,13 @@ class Storage:
                     return self._storage[item]
                 except ValueError:
                     pass
+
         if self.concrete:
             return symbol_factory.BitVecVal(0, 256)
-        self._storage[item] = symbol_factory.BitVecVal(0, 256)
+
+        self._storage[item] = symbol_factory.BitVecSym(
+            "storage_{}_{}".format(str(item), str(self.address)), 256
+        )
         return self._storage[item]
 
     def __setitem__(self, key: Union[int, str], value: Any) -> None:
@@ -74,10 +79,10 @@ class Account:
 
     def __init__(
         self,
-        address: str,
+        address: Union[BitVec, str],
         code=None,
         contract_name="unknown",
-        balance=None,
+        balances: Array = None,
         concrete_storage=False,
         dynamic_loader=None,
     ) -> None:
@@ -91,36 +96,51 @@ class Account:
         """
         self.nonce = 0
         self.code = code or Disassembly("")
-        self.balance = (
-            balance
-            if balance
-            else symbol_factory.BitVecSym("{}_balance".format(address), 256)
+        self.address = (
+            address
+            if isinstance(address, BitVec)
+            else symbol_factory.BitVecVal(int(address, 16), 256)
         )
+
         self.storage = Storage(
-            concrete_storage, address=address, dynamic_loader=dynamic_loader
+            concrete_storage, address=self.address, dynamic_loader=dynamic_loader
         )
+
         # Metadata
-        self.address = address
         self.contract_name = contract_name
 
         self.deleted = False
 
+        self._balances = balances
+        self.balance = lambda: self._balances[self.address]
+
     def __str__(self) -> str:
         return str(self.as_dict)
 
-    def set_balance(self, balance: ExprRef) -> None:
+    def set_balance(self, balance: Union[int, BitVec]) -> None:
         """
 
         :param balance:
         """
-        self.balance = balance
+        balance = (
+            symbol_factory.BitVecVal(balance, 256)
+            if isinstance(balance, int)
+            else balance
+        )
+        assert self._balances is not None
+        self._balances[self.address] = balance
 
-    def add_balance(self, balance: ExprRef) -> None:
+    def add_balance(self, balance: Union[int, BitVec]) -> None:
         """
 
         :param balance:
         """
-        self.balance += balance
+        balance = (
+            symbol_factory.BitVecVal(balance, 256)
+            if isinstance(balance, int)
+            else balance
+        )
+        self._balances[self.address] += balance
 
     @property
     def as_dict(self) -> Dict:
@@ -131,7 +151,7 @@ class Account:
         return {
             "nonce": self.nonce,
             "code": self.code,
-            "balance": self.balance,
+            "balance": self.balance(),
             "storage": self.storage,
         }
 
@@ -139,8 +159,8 @@ class Account:
         new_account = Account(
             address=self.address,
             code=self.code,
-            balance=self.balance,
             contract_name=self.contract_name,
+            balances=self._balances,
         )
         new_account.storage = deepcopy(self.storage)
         new_account.code = self.code

mythril/laser/ethereum/state/environment.py

@@ -39,7 +39,8 @@ class Environment:
         self.active_account = active_account
         self.active_function_name = ""
 
-        self.address = symbol_factory.BitVecVal(int(active_account.address, 16), 256)
+        self.address = active_account.address
+        self.block_number = symbol_factory.BitVecSym("block_number", 256)
 
         # Ib
         self.code = active_account.code if code is None else code

mythril/laser/ethereum/state/global_state.py

@@ -77,7 +77,7 @@ class GlobalState:
 
         :return:
         """
-        return self.world_state.accounts
+        return self.world_state._accounts
 
     # TODO: remove this, as two instructions are confusing
     def get_current_instruction(self) -> Dict:

mythril/laser/ethereum/state/machine_state.py

@@ -3,7 +3,7 @@ stack."""
 from copy import copy
 from typing import cast, Sized, Union, Any, List, Dict, Optional
 
-from mythril.laser.smt import BitVec, Expression
+from mythril.laser.smt import BitVec, Expression, symbol_factory
 
 from ethereum import opcodes, utils
 from mythril.laser.ethereum.evm_exceptions import (
@@ -32,6 +32,8 @@ class MachineStack(list):
         :param element: element to be appended to the list
         :function: appends the element to list if the size is less than STACK_LIMIT, else throws an error
         """
+        if isinstance(element, int):
+            element = symbol_factory.BitVecVal(element, 256)
         if super(MachineStack, self).__len__() >= self.STACK_LIMIT:
             raise StackOverflowException(
                 "Reached the EVM stack limit of {}, you can't append more "
@@ -123,7 +125,12 @@ class MachineState:
         """
         if self.memory_size > start + size:
             return 0
-        return start + size - self.memory_size
+
+        # The extension size is calculated based on the word length
+        new_size = utils.ceil32(start + size) // 32
+        old_size = self.memory_size // 32
+
+        return (new_size - old_size) * 32
 
     def calculate_memory_gas(self, start: int, size: int):
         """

mythril/laser/ethereum/state/memory.py

@@ -157,6 +157,8 @@ class Memory:
                 self[start + i] = cast(List[Union[int, BitVec]], value)[i]
 
         else:
+            if key >= len(self):
+                return
             if isinstance(value, int):
                 assert 0 <= value <= 0xFF
             if isinstance(value, BitVec):

mythril/laser/ethereum/state/world_state.py

@@ -2,6 +2,8 @@
 from copy import copy
 from random import randint
 from typing import Dict, List, Iterator, Optional, TYPE_CHECKING
+
+from mythril.laser.smt import symbol_factory, Array, BitVec
 from ethereum.utils import mk_contract_address
 from mythril.laser.ethereum.state.account import Account
 from mythril.laser.ethereum.state.annotation import StateAnnotation
@@ -22,18 +24,29 @@ class WorldState:
         :param transaction_sequence:
         :param annotations:
         """
-        self.accounts = {}  # type: Dict[str, Account]
+        self._accounts = {}  # type: Dict[int, Account]
+        self.balances = Array("balance", 256, 256)
+
         self.node = None  # type: Optional['Node']
         self.transaction_sequence = transaction_sequence or []
         self._annotations = annotations or []
 
-    def __getitem__(self, item: str) -> Account:
+    @property
+    def accounts(self):
+        return self._accounts
+
+    def __getitem__(self, item: BitVec) -> Account:
         """Gets an account from the worldstate using item as key.
 
         :param item: Address of the account to get
         :return: Account associated with the address
         """
-        return self.accounts[item]
+        try:
+            return self._accounts[item.value]
+        except KeyError:
+            new_account = Account(address=item, code=None, balances=self.balances)
+            self._accounts[item.value] = new_account
+            return new_account
 
     def __copy__(self) -> "WorldState":
         """
@@ -45,7 +58,9 @@ class WorldState:
             transaction_sequence=self.transaction_sequence[:],
             annotations=new_annotations,
         )
-        new_world_state.accounts = copy(self.accounts)
+        new_world_state.balances = copy(self.balances)
+        for account in self._accounts.values():
+            new_world_state.put_account(copy(account))
         new_world_state.node = self.node
         return new_world_state
 
@@ -65,14 +80,22 @@ class WorldState:
         :param dynamic_loader: used for dynamically loading storage from the block chain
         :return: The new account
         """
-        address = address if address else self._generate_new_address(creator)
+        address = (
+            symbol_factory.BitVecVal(address, 256)
+            if address
+            else self._generate_new_address(creator)
+        )
+
         new_account = Account(
-            address,
-            balance=balance,
+            address=address,
+            balances=self.balances,
             dynamic_loader=dynamic_loader,
             concrete_storage=concrete_storage,
         )
-        self._put_account(new_account)
+        if balance:
+            new_account.set_balance(symbol_factory.BitVecVal(balance, 256))
+
+        self.put_account(new_account)
         return new_account
 
     def create_initialized_contract_account(self, contract_code, storage) -> None:
@@ -86,10 +109,10 @@ class WorldState:
         """
         # TODO: Add type hints
         new_account = Account(
-            self._generate_new_address(), code=contract_code, balance=0
+            self._generate_new_address(), code=contract_code, balances=self.balances
         )
         new_account.storage = storage
-        self._put_account(new_account)
+        self.put_account(new_account)
 
     def annotate(self, annotation: StateAnnotation) -> None:
         """
@@ -116,22 +139,24 @@ class WorldState:
         """
         return filter(lambda x: isinstance(x, annotation_type), self.annotations)
 
-    def _generate_new_address(self, creator=None) -> str:
+    def _generate_new_address(self, creator=None) -> BitVec:
         """Generates a new address for the global state.
 
         :return:
         """
         if creator:
             # TODO: Use nounce
-            return "0x" + str(mk_contract_address(creator, 0).hex())
+            address = "0x" + str(mk_contract_address(creator, 0).hex())
+            return symbol_factory.BitVecVal(int(address, 16), 256)
         while True:
             address = "0x" + "".join([str(hex(randint(0, 16)))[-1] for _ in range(40)])
-            if address not in self.accounts.keys():
-                return address
+            if address not in self._accounts.keys():
+                return symbol_factory.BitVecVal(int(address, 16), 256)
 
-    def _put_account(self, account: Account) -> None:
+    def put_account(self, account: Account) -> None:
         """
 
         :param account:
         """
-        self.accounts[account.address] = account
+        self._accounts[account.address.value] = account
+        account._balances = self.balances

mythril/laser/ethereum/svm.py

@@ -9,12 +9,12 @@ from mythril.laser.ethereum.cfg import NodeFlags, Node, Edge, JumpType
 from mythril.laser.ethereum.evm_exceptions import StackUnderflowException
 from mythril.laser.ethereum.evm_exceptions import VmException
 from mythril.laser.ethereum.instructions import Instruction
-from mythril.laser.ethereum.state.account import Account
+from mythril.laser.ethereum.iprof import InstructionProfiler
+from mythril.laser.ethereum.plugins.signals import PluginSkipWorldState
 from mythril.laser.ethereum.state.global_state import GlobalState
 from mythril.laser.ethereum.state.world_state import WorldState
 from mythril.laser.ethereum.strategy.basic import DepthFirstSearchStrategy
 from mythril.laser.ethereum.time_handler import time_handler
-from mythril.laser.ethereum.plugins.signals import PluginSkipWorldState
 from mythril.laser.ethereum.transaction import (
     ContractCreationTransaction,
     TransactionEndSignal,
@@ -22,7 +22,7 @@ from mythril.laser.ethereum.transaction import (
     execute_contract_creation,
     execute_message_call,
 )
-from mythril.laser.ethereum.iprof import InstructionProfiler
+from mythril.laser.smt import symbol_factory
 
 log = logging.getLogger(__name__)
 
@@ -46,7 +46,6 @@ class LaserEVM:
 
     def __init__(
         self,
-        accounts: Dict[str, Account],
         dynamic_loader=None,
         max_depth=float("inf"),
         execution_timeout=60,
@@ -57,21 +56,18 @@ class LaserEVM:
         enable_iprof=False,
     ) -> None:
         """
-
-        :param accounts:
-        :param dynamic_loader:
-        :param max_depth:
-        :param execution_timeout:
-        :param create_timeout:
-        :param strategy:
-        :param transaction_count:
+        Initializes the laser evm object
+
+        :param dynamic_loader: Loads data from chain
+        :param max_depth: Maximum execution depth this vm should execute
+        :param execution_timeout: Time to take for execution
+        :param create_timeout: Time to take for contract creation
+        :param strategy: Execution search strategy
+        :param transaction_count: The amount of transactions to execute
+        :param requires_statespace: Variable indicating whether the statespace should be recorded
+        :param enable_iprof: Variable indicating whether instruction profiling should be turned on
         """
-        world_state = WorldState()
-        world_state.accounts = accounts
-        # this sets the initial world state
-        self.world_state = world_state
-        self.open_states = [world_state]
-
+        self.open_states = []  # type: List[WorldState]
         self.total_states = 0
         self.dynamic_loader = dynamic_loader
 
@@ -106,23 +102,30 @@ class LaserEVM:
 
         log.info("LASER EVM initialized with dynamic loader: " + str(dynamic_loader))
 
-    @property
-    def accounts(self) -> Dict[str, Account]:
-        """
-
-        :return:
-        """
-        return self.world_state.accounts
-
     def sym_exec(
-        self, main_address=None, creation_code=None, contract_name=None
+        self,
+        world_state: WorldState = None,
+        target_address: int = None,
+        creation_code: str = None,
+        contract_name: str = None,
     ) -> None:
+        """ Starts symbolic execution
+        There are two modes of execution.
+        Either we analyze a preconfigured configuration, in which case the world_state and target_address variables
+        must be supplied.
+        Or we execute the creation code of a contract, in which case the creation code and desired name of that
+        contract should be provided.
+
+        :param world_state The world state configuration from which to perform analysis
+        :param target_address The address of the contract account in the world state which analysis should target
+        :param creation_code The creation code to create the target contract in the symbolic environment
+        :param contract_name The name that the created account should be associated with
         """
+        pre_configuration_mode = world_state is not None and target_address is not None
+        scratch_mode = creation_code is not None and contract_name is not None
+        if pre_configuration_mode == scratch_mode:
+            raise ValueError("Symbolic execution started with invalid parameters")
 
-        :param main_address:
-        :param creation_code:
-        :param contract_name:
-        """
         log.debug("Starting LASER execution")
         for hook in self._start_sym_exec_hooks:
             hook()
@@ -130,11 +133,12 @@ class LaserEVM:
         time_handler.start_execution(self.execution_timeout)
         self.time = datetime.now()
 
-        if main_address:
-            log.info("Starting message call transaction to {}".format(main_address))
-            self._execute_transactions(main_address)
+        if pre_configuration_mode:
+            self.open_states = [world_state]
+            log.info("Starting message call transaction to {}".format(target_address))
+            self._execute_transactions(symbol_factory.BitVecVal(target_address, 256))
 
-        elif creation_code:
+        elif scratch_mode:
             log.info("Starting contract creation transaction")
             created_account = execute_contract_creation(
                 self, creation_code, contract_name
@@ -173,8 +177,9 @@ class LaserEVM:
         :param address: Address of the contract
         :return:
         """
+        self.time = datetime.now()
+
         for i in range(self.transaction_count):
-            self.time = datetime.now()
             log.info(
                 "Starting message call transaction, iteration: {}, {} initial states".format(
                     i, len(self.open_states)
@@ -206,8 +211,7 @@ class LaserEVM:
 
             if (
                 self.execution_timeout
-                and self.time
-                + timedelta(seconds=self.execution_timeout / self.transaction_count)
+                and self.time + timedelta(seconds=self.execution_timeout)
                 <= datetime.now()
                 and not create
             ):
@@ -355,7 +359,7 @@ class LaserEVM:
         if not revert_changes:
             return_global_state.world_state = copy(global_state.world_state)
             return_global_state.environment.active_account = global_state.accounts[
-                return_global_state.environment.active_account.address
+                return_global_state.environment.active_account.address.value
             ]
 
         # Execute the post instruction handler
@@ -389,19 +393,6 @@ class LaserEVM:
                 self._new_node_state(
                     state, JumpType.CONDITIONAL, state.mstate.constraints[-1]
                 )
-
-        elif opcode in ("CALL", "CALLCODE", "DELEGATECALL", "STATICCALL"):
-            assert len(new_states) <= 1
-            for state in new_states:
-                self._new_node_state(state, JumpType.CALL)
-                # Keep track of added contracts so the graph can be generated properly
-                if (
-                    state.environment.active_account.contract_name
-                    not in self.world_state.accounts.keys()
-                ):
-                    self.world_state.accounts[
-                        state.environment.active_account.address
-                    ] = state.environment.active_account
         elif opcode == "RETURN":
             for state in new_states:
                 self._new_node_state(state, JumpType.RETURN)
@@ -440,6 +431,7 @@ class LaserEVM:
                     new_node.flags |= NodeFlags.FUNC_ENTRY
             except StackUnderflowException:
                 new_node.flags |= NodeFlags.FUNC_ENTRY
+
         address = state.environment.code.instruction_list[state.mstate.pc]["address"]
 
         environment = state.environment

mythril/laser/ethereum/transaction/symbolic.py

@@ -2,25 +2,32 @@
 symbolic values."""
 import logging
 
-
-from mythril.laser.smt import symbol_factory
 from mythril.disassembler.disassembly import Disassembly
 from mythril.laser.ethereum.cfg import Node, Edge, JumpType
-from mythril.laser.ethereum.state.calldata import BaseCalldata, SymbolicCalldata
 from mythril.laser.ethereum.state.account import Account
+from mythril.laser.ethereum.state.calldata import SymbolicCalldata
+from mythril.laser.ethereum.state.world_state import WorldState
 from mythril.laser.ethereum.transaction.transaction_models import (
     MessageCallTransaction,
     ContractCreationTransaction,
     get_next_transaction_id,
+    BaseTransaction,
 )
+from mythril.laser.smt import symbol_factory, Or, BitVec
 
 log = logging.getLogger(__name__)
 
 CREATOR_ADDRESS = 0xAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFE
 ATTACKER_ADDRESS = 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF
 
+ACTOR_ADDRESSES = [
+    symbol_factory.BitVecVal(0xAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFEAFFE, 256),
+    symbol_factory.BitVecVal(0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF, 256),
+    symbol_factory.BitVecVal(0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEE, 256),
+]
+
 
-def execute_message_call(laser_evm, callee_address: str) -> None:
+def execute_message_call(laser_evm, callee_address: BitVec) -> None:
     """Executes a message call transaction from all open states.
 
     :param laser_evm:
@@ -46,7 +53,9 @@ def execute_message_call(laser_evm, callee_address: str) -> None:
             origin=symbol_factory.BitVecSym(
                 "origin{}".format(next_transaction_id), 256
             ),
-            caller=symbol_factory.BitVecVal(ATTACKER_ADDRESS, 256),
+            caller=symbol_factory.BitVecSym(
+                "sender_{}".format(next_transaction_id), 256
+            ),
             callee_account=open_world_state[callee_address],
             call_data=SymbolicCalldata(next_transaction_id),
             call_value=symbol_factory.BitVecSym(
@@ -69,12 +78,14 @@ def execute_contract_creation(
     :return:
     """
     # TODO: Resolve circular import between .transaction and ..svm to import LaserEVM here
-    open_states = laser_evm.open_states[:]
     del laser_evm.open_states[:]
 
-    new_account = laser_evm.world_state.create_account(
+    world_state = WorldState()
+    open_states = [world_state]
+    new_account = world_state.create_account(
         0, concrete_storage=True, dynamic_loader=None, creator=CREATOR_ADDRESS
     )
+
     if contract_name:
         new_account.contract_name = contract_name
 
@@ -104,7 +115,7 @@ def execute_contract_creation(
     return new_account
 
 
-def _setup_global_state_for_execution(laser_evm, transaction) -> None:
+def _setup_global_state_for_execution(laser_evm, transaction: BaseTransaction) -> None:
     """Sets up global state and cfg for a transactions execution.
 
     :param laser_evm:
@@ -114,6 +125,10 @@ def _setup_global_state_for_execution(laser_evm, transaction) -> None:
     global_state = transaction.initial_global_state()
     global_state.transaction_stack.append((transaction, None))
 
+    global_state.mstate.constraints.append(
+        Or(*[transaction.caller == actor for actor in ACTOR_ADDRESSES])
+    )
+
     new_node = Node(
         global_state.environment.active_account.contract_name,
         function_name=global_state.environment.active_function_name,

mythril/laser/ethereum/transaction/transaction_models.py

@@ -111,8 +111,19 @@ class BaseTransaction:
         # Initialize the execution environment
         global_state = GlobalState(self.world_state, environment, None)
         global_state.environment.active_function_name = active_function
+
+        sender = environment.sender
+        receiver = environment.active_account.address
+        value = environment.callvalue
+
+        global_state.world_state.balances[sender] -= value
+        global_state.world_state.balances[receiver] += value
+
         return global_state
 
+    def initial_global_state(self) -> GlobalState:
+        raise NotImplementedError
+
 
 class MessageCallTransaction(BaseTransaction):
     """Transaction object models an transaction."""
@@ -143,6 +154,7 @@ class MessageCallTransaction(BaseTransaction):
         :param revert:
         """
         self.return_data = return_data
+
         raise TransactionEndSignal(global_state, revert)
 
 
@@ -190,7 +202,9 @@ class ContractCreationTransaction(BaseTransaction):
         contract_code = bytes.hex(array.array("B", return_data).tostring())
 
         global_state.environment.active_account.code.assign_bytecode(contract_code)
-        self.return_data = global_state.environment.active_account.address
+        self.return_data = str(
+            hex(global_state.environment.active_account.address.value)
+        )
         assert global_state.environment.active_account.code.instruction_list != []
 
         raise TransactionEndSignal(global_state, revert=revert)

mythril/laser/smt/bool.py

@@ -93,15 +93,16 @@ def And(*args: Union[Bool, bool]) -> Bool:
     return Bool(z3.And([a.raw for a in args_list]), union)
 
 
-def Or(a: Bool, b: Bool) -> Bool:
+def Or(*args: Union[Bool, bool]) -> Bool:
     """Create an or expression.
 
     :param a:
     :param b:
     :return:
     """
-    union = a.annotations + b.annotations
-    return Bool(z3.Or(a.raw, b.raw), annotations=union)
+    args_list = [arg if isinstance(arg, Bool) else Bool(arg) for arg in args]
+    union = [arg.annotations for arg in args_list]
+    return Bool(z3.Or([a.raw for a in args_list]), annotations=union)
 
 
 def Not(a: Bool) -> Bool:

mythril/mythril/mythril_analyzer.py

@@ -75,6 +75,7 @@ class MythrilAnalyzer:
             execution_timeout=self.execution_timeout,
             create_timeout=self.create_timeout,
             enable_iprof=self.enable_iprof,
+            run_analysis_modules=False,
         )
 
         return get_serializable_statespace(sym)
@@ -108,6 +109,7 @@ class MythrilAnalyzer:
             transaction_count=transaction_count,
             create_timeout=self.create_timeout,
             enable_iprof=self.enable_iprof,
+            run_analysis_modules=False,
         )
         return generate_graph(sym, physics=enable_physics, phrackify=phrackify)
 

mythril/solidity/soliditycontract.py

@@ -1,5 +1,7 @@
 """This module contains representation classes for Solidity files, contracts
 and source mappings."""
+from typing import Dict, Set
+
 import mythril.laser.ethereum.util as helper
 from mythril.ethereum.evmcontract import EVMContract
 from mythril.ethereum.util import get_solc_json
@@ -20,9 +22,16 @@ class SourceMapping:
 class SolidityFile:
     """Representation of a file containing Solidity code."""
 
-    def __init__(self, filename, data):
+    def __init__(self, filename: str, data: str, full_contract_src_maps: Set[str]):
+        """
+        Metadata class containing data regarding a specific solidity file
+        :param filename: The filename of the solidity file
+        :param data: The code of the solidity file
+        :param full_contract_src_maps: The set of contract source mappings of all the contracts in the file
+        """
         self.filename = filename
         self.data = data
+        self.full_contract_src_maps = full_contract_src_maps
 
 
 class SourceCodeInfo:
@@ -69,7 +78,12 @@ class SolidityContract(EVMContract):
         for filename in data["sourceList"]:
             with open(filename, "r", encoding="utf-8") as file:
                 code = file.read()
-                self.solidity_files.append(SolidityFile(filename, code))
+                full_contract_src_maps = self.get_full_contract_src_maps(
+                    data["sources"][filename]["AST"]
+                )
+                self.solidity_files.append(
+                    SolidityFile(filename, code, full_contract_src_maps)
+                )
 
         has_contract = False
 
@@ -117,6 +131,19 @@ class SolidityContract(EVMContract):
 
         super().__init__(code, creation_code, name=name)
 
+    @staticmethod
+    def get_full_contract_src_maps(ast: Dict) -> Set[str]:
+        """
+        Takes a solc AST and gets the src mappings for all the contracts defined in the top level of the ast
+        :param ast: AST of the contract
+        :return: The source maps
+        """
+        source_maps = set()
+        for child in ast["children"]:
+            if "contractKind" in child["attributes"]:
+                source_maps.add(child["src"])
+        return source_maps
+
     def get_source_info(self, address, constructor=False):
         """
 
@@ -140,6 +167,26 @@ class SolidityContract(EVMContract):
         lineno = mappings[index].lineno
         return SourceCodeInfo(filename, lineno, code, mappings[index].solc_mapping)
 
+    def _is_autogenerated_code(self, offset: int, length: int, file_index: int) -> bool:
+        """
+        Checks whether the code is autogenerated or not
+        :param offset: offset of the code
+        :param length: length of the code
+        :param file_index: file the code corresponds to
+        :return: True if the code is internally generated, else false
+        """
+        # Handle internal compiler files
+        if file_index == -1:
+            return True
+        # Handle the common code src map for the entire code.
+        if (
+            "{}:{}:{}".format(offset, length, file_index)
+            in self.solidity_files[file_index].full_contract_src_maps
+        ):
+            return True
+
+        return False
+
     def _get_solc_mappings(self, srcmap, constructor=False):
         """
 
@@ -161,7 +208,8 @@ class SolidityContract(EVMContract):
 
             if len(mapping) > 2 and len(mapping[2]) > 0:
                 idx = int(mapping[2])
-            if idx == -1:
+
+            if self._is_autogenerated_code(offset, length, idx):
                 lineno = None
             else:
                 lineno = (

requirements.txt

@@ -3,12 +3,12 @@ configparser>=3.5.0
 coverage
 py_ecc==1.4.2
 eth_abi==1.3.0
-eth-account>=0.1.0a2
+eth-account>=0.1.0a2,<=0.3.0
 ethereum>=2.3.2
 ethereum-input-decoder>=0.2.2
 eth-hash>=0.1.0
 eth-keyfile>=0.5.1
-eth-keys>=0.2.0b3
+eth-keys>=0.2.0b3,<0.3.0
 eth-rlp>=0.1.0
 eth-tester==0.1.0b32
 eth-typing>=2.0.0
@@ -25,6 +25,6 @@ pytest_mock
 requests
 rlp>=1.0.1
 transaction>=2.2.1
-z3-solver-mythril>=4.8.4.1
+z3-solver>=4.8.5.0
 pysha3
 matplotlib

setup.py

@@ -9,21 +9,82 @@ publish to pypi w/o having to convert Readme.md to RST:
 """
 from setuptools import setup, find_packages
 from setuptools.command.install import install
-from pathlib import Path
 import sys
 import os
+import io
 
-# To make lint checkers happy we set VERSION here, but
-# it is redefined by the exec below
+# Package meta-data.
+NAME = "mythril"
+DESCRIPTION = "Security analysis tool for Ethereum smart contracts"
+URL = "https://github.com/ConsenSys/mythril"
+AUTHOR = "ConsenSys Dilligence"
+AUTHOR_MAIL = None
+REQUIRES_PYTHON = ">=3.5.0"
+
+
+# What packages are required for this module to be executed?
+REQUIRED = [
+    "coloredlogs>=10.0",
+    "py_ecc==1.4.2",
+    "ethereum>=2.3.2",
+    "z3-solver>=4.8.5.0",
+    "requests",
+    "py-solc",
+    "plyvel",
+    "eth_abi==1.3.0",
+    "eth-utils>=1.0.1",
+    "eth-account>=0.1.0a2,<=0.3.0",
+    "eth-hash>=0.1.0",
+    "eth-keyfile>=0.5.1",
+    "eth-keys>=0.2.0b3,<0.3.0",
+    "eth-rlp>=0.1.0",
+    "eth-tester==0.1.0b32",
+    "eth-typing>=2.0.0",
+    "coverage",
+    "jinja2>=2.9",
+    "rlp>=1.0.1",
+    "transaction>=2.2.1",
+    "py-flags",
+    "mock",
+    "configparser>=3.5.0",
+    "persistent>=4.2.0",
+    "ethereum-input-decoder>=0.2.2",
+    "matplotlib",
+]
+
+TESTS_REQUIRE = ["mypy", "pytest>=3.6.0", "pytest_mock", "pytest-cov"]
+
+# What packages are optional?
+EXTRAS = {
+    # 'fancy feature': ['django'],
+}
+
+# If version is set to None then it will be fetched from __version__.py
 VERSION = None
 
-# Package version (vX.Y.Z). It must match git tag being used for CircleCI
-# deployment; otherwise the build will failed.
+here = os.path.abspath(os.path.dirname(__file__))
+
+# Import the README and use it as the long-description.
+# Note: this will only work if 'README.md' is present in your MANIFEST.in file!
+try:
+    with io.open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+        long_description = "\n" + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
 
-version_path = (Path(__file__).parent / "mythril" / "version.py").absolute()
-exec(open(str(version_path), "r").read())
 
+# Load the package's __version__.py module as a dictionary.
+about = {}
+if not VERSION:
+    project_slug = NAME.lower().replace("-", "_").replace(" ", "_")
+    with open(os.path.join(here, project_slug, "__version__.py")) as f:
+        exec(f.read(), about)
+else:
+    about["__version__"] = VERSION
 
+
+# Package version (vX.Y.Z). It must match git tag being used for CircleCI
+# deployment; otherwise the build will failed.
 class VerifyVersionCommand(install):
     """Custom command to verify that the git tag matches our version."""
 
@@ -40,25 +101,15 @@ class VerifyVersionCommand(install):
             sys.exit(info)
 
 
-def read_file(fname):
-    """return file contents.
-
-    :param fname: path relative to setup.py
-    :return: file contents
-    """
-    with open(os.path.join(os.path.dirname(__file__), fname), "r") as fd:
-        return fd.read()
-
-
 setup(
-    name="mythril",
-    version=VERSION[1:],
-    description="Security analysis tool for Ethereum smart contracts",
-    long_description=read_file("README.md") if os.path.isfile("README.md") else "",
+    name=NAME,
+    version=about["__version__"][1:],
+    description=DESCRIPTION,
+    long_description=long_description,
     long_description_content_type="text/markdown",  # requires twine and recent setuptools
-    url="https://github.com/b-mueller/mythril",
-    author="Bernhard Mueller",
-    author_email="bernhard.mueller11@gmail.com",
+    url=URL,
+    author=AUTHOR,
+    author_mail=AUTHOR_MAIL,
     license="MIT",
     classifiers=[
         "Development Status :: 3 - Alpha",
@@ -71,37 +122,10 @@ setup(
     ],
     keywords="hacking disassembler security ethereum",
     packages=find_packages(exclude=["contrib", "docs", "tests"]),
-    install_requires=[
-        "coloredlogs>=10.0",
-        "py_ecc==1.4.2",
-        "ethereum>=2.3.2",
-        "z3-solver-mythril>=4.8.4.1",
-        "requests",
-        "py-solc",
-        "plyvel",
-        "eth_abi==1.3.0",
-        "eth-utils>=1.0.1",
-        "eth-account>=0.1.0a2",
-        "eth-hash>=0.1.0",
-        "eth-keyfile>=0.5.1",
-        "eth-keys>=0.2.0b3",
-        "eth-rlp>=0.1.0",
-        "eth-tester==0.1.0b32",
-        "eth-typing>=2.0.0",
-        "coverage",
-        "jinja2>=2.9",
-        "rlp>=1.0.1",
-        "transaction>=2.2.1",
-        "py-flags",
-        "mock",
-        "configparser>=3.5.0",
-        "persistent>=4.2.0",
-        "ethereum-input-decoder>=0.2.2",
-        "matplotlib",
-    ],
-    tests_require=["mypy", "pytest>=3.6.0", "pytest_mock", "pytest-cov"],
-    python_requires=">=3.5",
-    extras_require={},
+    install_requires=REQUIRED,
+    tests_require=TESTS_REQUIRE,
+    python_requires=REQUIRES_PYTHON,
+    extras_require=EXTRAS,
     package_data={"mythril.analysis.templates": ["*"], "mythril.support.assets": ["*"]},
     include_package_data=True,
     entry_points={"console_scripts": ["myth=mythril.interfaces.cli:main"]},

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_AfterJumpdest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJump0_AfterJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_AfterJumpdestFiller.json",
+            "sourceHash" : "edd08521b4a9bc311f2ba99d15c867d9a98da1e9665d9b173ff85621e170e896"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600843015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600843015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_AfterJumpdest3.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJump0_AfterJumpdest3" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_AfterJumpdest3Filler.json",
+            "sourceHash" : "1e86dccd54bd74436a1bbfe11302b675761fc6138ebd1461231acd29ee97b0f0"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600b60085043015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600b60085043015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_foreverOutOfGas.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJump0_foreverOutOfGas" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_foreverOutOfGasFiller.json",
+            "sourceHash" : "0900beba73811b8aafaefadcff3a7cd9954ccb5e4986b9cf03ca44881efd4e9c"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x5b600060000156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x5b600060000156",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_jumpdest0.json

@@ -0,0 +1,52 @@
+{
+    "BlockNumberDynamicJump0_jumpdest0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_jumpdest0Filler.json",
+            "sourceHash" : "80bfa0a5db107e6f083dccdd3091e35add39a4eaac4a8757de8a3e4008c5d646"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600743015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013869",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600743015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600743015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_jumpdest2.json

@@ -0,0 +1,52 @@
+{
+    "BlockNumberDynamicJump0_jumpdest2" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_jumpdest2Filler.json",
+            "sourceHash" : "e86a87e0b5cde7d47f1e5dc295600ecc60b7344b3fb4ad64609d6b87fae642f8"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600a60085043015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013864",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a60085043015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a60085043015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump0_withoutJumpdest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJump0_withoutJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump0_withoutJumpdestFiller.json",
+            "sourceHash" : "6f1fc4a9e5dff3e5d3071c576aba5b2ee1f30d7dcace92e6c6d230cfd415efd7"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x602360074301566001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360074301566001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJump1.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJump1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJump1Filler.json",
+            "sourceHash" : "88e43b5985cc4dfbcbc8476c570157e6e7bc0ee0cb3609e9e9f3dd9aa2a3a528"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x620fffff620fffff01430156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x620fffff620fffff01430156",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpInsidePushWithJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpInsidePushWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpInsidePushWithJumpDestFiller.json",
+            "sourceHash" : "ca0f21a5f52a8d4f2d6e1eed650f68d5f8f40e567cf17984aacc228adfa578ab"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6004430156655b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6004430156655b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpInsidePushWithoutJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpInsidePushWithoutJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpInsidePushWithoutJumpDestFiller.json",
+            "sourceHash" : "183a4ce2d0f208630db92539aaf4e38fc3025b44a2842e19e39e956465449fe5"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x600543015661eeff",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600543015661eeff",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpi0.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpi0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpi0Filler.json",
+            "sourceHash" : "620bba922f5a1732f512d726a26e71b09d3837018a66a9aacb581b212a4f4b13"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600160094301576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600160094301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpi1.json

@@ -0,0 +1,52 @@
+{
+    "BlockNumberDynamicJumpi1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpi1Filler.json",
+            "sourceHash" : "91d6fe3848fbdafff10b7bd503d560f2c614d6b53ed16b51821d3026f4a3a544"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600060094301576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013862",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600060094301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x01"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600060094301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpi1_jumpdest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpi1_jumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpi1_jumpdestFiller.json",
+            "sourceHash" : "420810639c740487f7b8d18b29f28dcfb7d762b1aa4aa9b9f8b91928da66a539"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236001600a43015760015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236001600a43015760015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpiAfterStop.json

@@ -0,0 +1,52 @@
+{
+    "BlockNumberDynamicJumpiAfterStop" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpiAfterStopFiller.json",
+            "sourceHash" : "7331cec587701bf695329ad94c7e62963827209faffac3b24eb59341ccb1a925"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x600160084301570060015b6002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013864",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600160084301570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x03" : "0x02"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600160084301570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpiOutsideBoundary.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpiOutsideBoundary" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpiOutsideBoundaryFiller.json",
+            "sourceHash" : "db80ec0400be086e2a316a91ee7a5f87db06ff6a5b0ad27a50ba692049a54b1c"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60017ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04301576002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60017ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04301576002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpifInsidePushWithJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpifInsidePushWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpifInsidePushWithJumpDestFiller.json",
+            "sourceHash" : "4b52bc3a45a966d0032eb01b3fdb8a225af48fa4f5a017b5dff3d4d88d710337"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016006430157655b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016006430157655b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/BlockNumberDynamicJumpifInsidePushWithoutJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "BlockNumberDynamicJumpifInsidePushWithoutJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/BlockNumberDynamicJumpifInsidePushWithoutJumpDestFiller.json",
+            "sourceHash" : "3fccd0c56ebfd40dea69fec03d009967a80ddf93e9a68af81efd2d1645e27fcb"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6001600743015761eeff",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6001600743015761eeff",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DyanmicJump0_outOfBoundary.json

@@ -0,0 +1,38 @@
+{
+    "DyanmicJump0_outOfBoundary" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DyanmicJump0_outOfBoundaryFiller.json",
+            "sourceHash" : "a2ae635e97f7381a5af1ea432d210faf19f4f84e8e0e6874bd48005674bfea92"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600760005401566001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600760005401566001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_AfterJumpdest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump0_AfterJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_AfterJumpdestFiller.json",
+            "sourceHash" : "605f607251cd4a7c73bd7c814edcada6a9008fcd2896af2caf371beb31db196b"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x602360086003015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360086003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_AfterJumpdest3.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump0_AfterJumpdest3" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_AfterJumpdest3Filler.json",
+            "sourceHash" : "b7367314ce66b1a937c05550ac901971b5850d2a0ef03acf1feb4d6c9f38925d"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600b6008506003015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600b6008506003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_foreverOutOfGas.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump0_foreverOutOfGas" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_foreverOutOfGasFiller.json",
+            "sourceHash" : "68b687a344b0f44d7459e095f05f6b302ee3f5d15b3c3e7765d5642fb1f46689"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x5b600060000156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x5b600060000156",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_jumpdest0.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJump0_jumpdest0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_jumpdest0Filler.json",
+            "sourceHash" : "3ab9d036e3e345909b19022f4c3b80d081d214eb5c79b8e94e0f2c660ab01ec7"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x602360076003015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013868",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360076003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360076003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_jumpdest2.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJump0_jumpdest2" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_jumpdest2Filler.json",
+            "sourceHash" : "a7e9d9f046151930ef4b51b8dacce5304ce74c3f5ead80f1e52f783b1a704378"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600a6008506003015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013863",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a6008506003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a6008506003015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump0_withoutJumpdest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump0_withoutJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump0_withoutJumpdestFiller.json",
+            "sourceHash" : "84c524e0cafc2ddcebdef720e46a23d10061f4a35bb06bfe7bdfe444990593a6"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236007600301566001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236007600301566001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump1.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump1Filler.json",
+            "sourceHash" : "2369bac56afc1e0946f608c52027fbc88faf3844cdc2fa46954a0916221b8432"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x620fffff620fffff0160030156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x620fffff620fffff0160030156",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpAfterStop.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpAfterStop" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpAfterStopFiller.json",
+            "sourceHash" : "5ba8a9cb65319cdc8e574e0eb59695b55158e6d723945bac3b96573a576a86a8"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6008600101560060015b6002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013868",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6008600101560060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x03" : "0x02"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6008600101560060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpInsidePushWithJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpInsidePushWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpInsidePushWithJumpDestFiller.json",
+            "sourceHash" : "3f3586292e12e696029f38f833fe8c7cea86a0e7cda83c0cbe783aa2c3b22b0c"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x600460030156655b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600460030156655b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpInsidePushWithoutJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpInsidePushWithoutJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpInsidePushWithoutJumpDestFiller.json",
+            "sourceHash" : "4e320bace2f65884d59f95dbbba6e4f9aea39e243bffd309be9bb6c5a3c1bedb"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60056003015661eeff",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60056003015661eeff",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpJD_DependsOnJumps0.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpJD_DependsOnJumps0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpJD_DependsOnJumps0Filler.json",
+            "sourceHash" : "e96143bec9697fb0d565026f5fcc5ed70833bf89eb8c63aa87e0155b4e61d8f4"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x01",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6009436006575b566001",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6009436006575b566001",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpJD_DependsOnJumps1.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpJD_DependsOnJumps1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpJD_DependsOnJumps1Filler.json",
+            "sourceHash" : "853f3f35881b9db63508e68d34cf87a1a3697fdc969821c0659462242d859c2b"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x01",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x600a436006575b5660015b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x01385e",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600a436006575b5660015b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x01" : "0x01"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600a436006575b5660015b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpPathologicalTest0.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpPathologicalTest0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpPathologicalTest0Filler.json",
+            "sourceHash" : "6862ac2a8fad0b3c043493fcd9c9a7e8a549c9f3ef34019ac0d7bcfd096a8040"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x04",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x435660615b4343025660615b60615b5b5b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x01385d",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x435660615b4343025660615b60615b5b5b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x01" : "0x01"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x435660615b4343025660615b60615b5b5b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpPathologicalTest1.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpPathologicalTest1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpPathologicalTest1Filler.json",
+            "sourceHash" : "dfbad553b0e28f37f6a5d72740e2ae6bf17ce1b19c62caf2cc2a99c0d1d84e05"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x04",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x435660615b4343025660615b60615b605b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x435660615b4343025660615b60615b605b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpPathologicalTest2.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpPathologicalTest2" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpPathologicalTest2Filler.json",
+            "sourceHash" : "957bc609a0322452da86a59c96e7eea17c5463dcd7bad6ed97b57c6460a90b80"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x04",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x435631615b60615b60615b606001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x435631615b60615b60615b606001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpPathologicalTest3.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpPathologicalTest3" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpPathologicalTest3Filler.json",
+            "sourceHash" : "a906b3dcb41da1cdacb67bdf49111ecd2bdaab0e3584dbd3993ef0f0555766f6"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x07",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x435631615b60615b60615b606001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x435631615b60615b60615b606001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpStartWithJumpDest.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpStartWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpStartWithJumpDestFiller.json",
+            "sourceHash" : "4fb19acd65703dce630cb655f52e98d2de72d8a790d53b895d0e7bce603d4166"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x5b586000555960115758600052596000575b58600055",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x011126",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x5b586000555960115758600052596000575b58600055",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x12"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x5b586000555960115758600052596000575b58600055",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump_value1.json

@@ -0,0 +1,51 @@
+{
+    "DynamicJump_value1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump_value1Filler.json",
+            "sourceHash" : "20503c4d21019e3d9d87b95365a0d0417fb7e163265f938d6e3f685377a2c5da"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x08"
+        },
+        "gas" : "0x01867a",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x0000000000000000000000000000000000000000000000000000000000000001",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump_value2.json

@@ -0,0 +1,51 @@
+{
+    "DynamicJump_value2" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump_value2Filler.json",
+            "sourceHash" : "00631169ba52dbbd3d7ac8529dd960c6b297226c0f177ee3e0ef8bd202b4b1ff"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x12"
+        },
+        "gas" : "0x01867c",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x0000000000000000000000000000000000000000000000000000000000000002",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump_value3.json

@@ -0,0 +1,51 @@
+{
+    "DynamicJump_value3" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump_value3Filler.json",
+            "sourceHash" : "a1477eeb656e1f4d09c07f020a088cc099f6661fce88f137754b1d45550d7218"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x1b"
+        },
+        "gas" : "0x01867e",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x0000000000000000000000000000000000000000000000000000000000000003",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJump_valueUnderflow.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJump_valueUnderflow" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJump_valueUnderflowFiller.json",
+            "sourceHash" : "37f012edfeaa13e4819617af0e8dc2fd71d738a2463b1f61bfd86de0ef980f1b"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b505050600052596000f3",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x1b"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016002600334565b5050600052596000f35b50600052596000f35b505050600052596000f3",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpi0.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpi0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpi0Filler.json",
+            "sourceHash" : "394cae3e06d120cc1a5df5e14cfae3598d62e1fefa06dce4055c6ff59c367b63"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x602360016009600301576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360016009600301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpi1.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpi1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpi1Filler.json",
+            "sourceHash" : "31d323d1c24dd2c2ea5a4e18fd0765bfa1be189add7e395b2679bf5a98e492ab"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x602360006009600301576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013861",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360006009600301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x02" : "0x01"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x602360006009600301576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpi1_jumpdest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpi1_jumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpi1_jumpdestFiller.json",
+            "sourceHash" : "fb4060a7f68c0f3ad9643dcfc93fa90ea0fe6123e65499ae65f400e22db20bcc"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236001600a6003015760015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236001600a6003015760015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpiAfterStop.json

@@ -0,0 +1,52 @@
+{
+    "DynamicJumpiAfterStop" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpiAfterStopFiller.json",
+            "sourceHash" : "d61d45e9d5ea3e13d2a8a33965c9c620207156e0b4baf2dfed9a0288c7e8053b"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60016008600301570060015b6002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013863",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016008600301570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x03" : "0x02"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60016008600301570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpiOutsideBoundary.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpiOutsideBoundary" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpiOutsideBoundaryFiller.json",
+            "sourceHash" : "d550aa41047204857f27b7a80a1309520f3e59b41a87ef3e40492032706e5a88"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60017ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0600301576002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60017ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0600301576002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpifInsidePushWithJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpifInsidePushWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpifInsidePushWithJumpDestFiller.json",
+            "sourceHash" : "05f764377385769e93afe47dbc0293921c211b4e68afce30f18cba4bb5955420"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6001600660030157655b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6001600660030157655b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/DynamicJumpifInsidePushWithoutJumpDest.json

@@ -0,0 +1,37 @@
+{
+    "DynamicJumpifInsidePushWithoutJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/DynamicJumpifInsidePushWithoutJumpDestFiller.json",
+            "sourceHash" : "cadedb13e141e3b7bf1f0763cc831dace3ff150fc623e81fb00e798168d01188"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x00",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x600160076003015761eeff",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x600160076003015761eeff",
+                "nonce" : "0x00",
+                "storage" : {
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_AfterJumpdest.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJump0_AfterJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_AfterJumpdestFiller.json",
+            "sourceHash" : "06126bb58e44948750e412ea81a3140fcc72b63acec0090939706f3ceb403ae8"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236008600054015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236008600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_AfterJumpdest3.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJump0_AfterJumpdest3" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_AfterJumpdest3Filler.json",
+            "sourceHash" : "52880726a50d86ffdaea78e4a5d3293643688543eea049172fbf51e564f28f5b"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600b600850600054015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600b600850600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_foreverOutOfGas.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJump0_foreverOutOfGas" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_foreverOutOfGasFiller.json",
+            "sourceHash" : "a3046ce1b7f78c109aa36c29db004850ad5b3b4129d9085849b7af04b719826c"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x5b600060000156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x5b600060000156",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_jumpdest0.json

@@ -0,0 +1,54 @@
+{
+    "JDfromStorageDynamicJump0_jumpdest0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_jumpdest0Filler.json",
+            "sourceHash" : "2f836ba88951147677580e5de7d8d40b0ca72938894aa351096945d7962c8f62"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236007600054015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013836",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236007600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04",
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236007600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_jumpdest2.json

@@ -0,0 +1,54 @@
+{
+    "JDfromStorageDynamicJump0_jumpdest2" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_jumpdest2Filler.json",
+            "sourceHash" : "efe088c5366793bcb3339225486608b15750524274baf8d5f9f592c0d5e327f2"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600a600850600054015660015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013831",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a600850600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04",
+                    "0x02" : "0x23"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600a600850600054015660015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump0_withoutJumpdest.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJump0_withoutJumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump0_withoutJumpdestFiller.json",
+            "sourceHash" : "696ced07844f15bee009a7c294048b5bf531923787279c19bf1c3150a46bf0ff"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6023600760005401566001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6023600760005401566001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJump1.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJump1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJump1Filler.json",
+            "sourceHash" : "bf061c0eb83d11c310f7ec309e56c3629f715727b41cc0e0772991060404cfc9"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x620fffff620fffff016000540156",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x620fffff620fffff016000540156",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpInsidePushWithJumpDest.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJumpInsidePushWithJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpInsidePushWithJumpDestFiller.json",
+            "sourceHash" : "561a67bc9db1011fb26151b03adcc53b2f4f55e03292c1e98e3361250c87d38a"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60046000540156655b6001600155",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60046000540156655b6001600155",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpInsidePushWithoutJumpDest.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJumpInsidePushWithoutJumpDest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpInsidePushWithoutJumpDestFiller.json",
+            "sourceHash" : "53a491adcc7da05748ad36809954552784007b884cd960e05ebb07a2ddd0452b"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6005600054015661eeff",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6005600054015661eeff",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpi0.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJumpi0" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpi0Filler.json",
+            "sourceHash" : "14e786db1b2df2c2a40be1a80c61baec311572eb481a3afd1b31fb95a3ad937d"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236001600960005401576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236001600960005401576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpi1.json

@@ -0,0 +1,54 @@
+{
+    "JDfromStorageDynamicJumpi1" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpi1Filler.json",
+            "sourceHash" : "f90389bdfe2c1600f16db3b5ff8289b55a9f3d2c56dd18403c4e636440a98a9d"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236000600960005401576001600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x01382f",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236000600960005401576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04",
+                    "0x02" : "0x01"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236000600960005401576001600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpi1_jumpdest.json

@@ -0,0 +1,38 @@
+{
+    "JDfromStorageDynamicJumpi1_jumpdest" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpi1_jumpdestFiller.json",
+            "sourceHash" : "cc7eadaee4927a2753204e40d7028ae1ed3e1ef4c9a2e8a79460a3e07f5bcafe"
+        },
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x60236001600a600054015760015b600255",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x60236001600a600054015760015b600255",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}

tests/laser/evm_testsuite/VMTests/vmIOandFlowOperations/JDfromStorageDynamicJumpiAfterStop.json

@@ -0,0 +1,54 @@
+{
+    "JDfromStorageDynamicJumpiAfterStop" : {
+        "_info" : {
+            "comment" : "",
+            "filledwith" : "testeth 1.5.0.dev2-52+commit.d419e0a2",
+            "lllcversion" : "Version: 0.4.26-develop.2018.9.19+commit.785cbf40.Linux.g++",
+            "source" : "src/VMTestsFiller/vmIOandFlowOperations/JDfromStorageDynamicJumpiAfterStopFiller.json",
+            "sourceHash" : "80d903064c1050cf1a2e527b8938e610e77822d55c83cf4a07e18586baa0bec1"
+        },
+        "callcreates" : [
+        ],
+        "env" : {
+            "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+            "currentDifficulty" : "0x0100",
+            "currentGasLimit" : "0x0f4240",
+            "currentNumber" : "0x02",
+            "currentTimestamp" : "0x01"
+        },
+        "exec" : {
+            "address" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "caller" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "code" : "0x6001600860005401570060015b6002600355",
+            "data" : "0x",
+            "gas" : "0x0186a0",
+            "gasPrice" : "0x5af3107a4000",
+            "origin" : "0xcd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "0x0de0b6b3a7640000"
+        },
+        "gas" : "0x013831",
+        "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "out" : "0x",
+        "post" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6001600860005401570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04",
+                    "0x03" : "0x02"
+                }
+            }
+        },
+        "pre" : {
+            "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+                "balance" : "0x152d02c7e14af6800000",
+                "code" : "0x6001600860005401570060015b6002600355",
+                "nonce" : "0x00",
+                "storage" : {
+                    "0x00" : "0x04"
+                }
+            }
+        }
+    }
+}