diff --git a/pytezos/repl/blockchain.py b/pytezos/repl/blockchain.py
index e1183ca15..bd74fc097 100644
--- a/pytezos/repl/blockchain.py
+++ b/pytezos/repl/blockchain.py
@@ -161,8 +161,9 @@ def do_implicit_account(ctx: Context, prim, args, annots):
 
 def decrease_balance(ctx: Context, amount: Mutez):
     balance = get_balance(ctx)
-    assert int(amount) <= int(balance), f'needed {int(amount)} utz, got only {int(balance)} utz'
-    ctx.set('BALANCE', Mutez(int(balance) - int(amount)))
+    if int(balance) > 0:
+        assert int(amount) <= int(balance), f'needed {int(amount)} utz, got only {int(balance)} utz'
+        ctx.set('BALANCE', Mutez(int(balance) - int(amount)))
 
 
 @instruction('CREATE_CONTRACT', args_len=1)
@@ -177,6 +178,7 @@ def do_create_contract(ctx: Context, prim, args, annots):
     assert_stack_type(delegate, Option)
     assert_equal_types(storage_type, storage.type_expr)
 
+    originated_address = Address.new(ctx.dummy_gen.get_fresh_address())
     content = {
         'kind': 'origination',
         'source': ctx.dummy_gen.self,
@@ -184,13 +186,13 @@ def do_create_contract(ctx: Context, prim, args, annots):
         'script': {
             'storage': storage.val_expr,
             'code': code
-        }
+        },
+        'originated_contract': str(originated_address)
     }
 
     if not delegate.is_none():
         content['delegate'] = str(delegate.get_some())
 
-    originated_address = Address.new(ctx.dummy_gen.get_fresh_address())
     orig = Operation.new(content)
     ctx.push(originated_address)
     ctx.push(orig)
diff --git a/pytezos/repl/context.py b/pytezos/repl/context.py
index d42600cde..cabbb1ded 100644
--- a/pytezos/repl/context.py
+++ b/pytezos/repl/context.py
@@ -61,24 +61,24 @@ def spawn(self, stack):
         return ctx
 
     def reset(self):
-        self.stdout.clear()
+        self.stdout = []
         self.pushed = False
 
     def protect(self, count: int):
         assert len(self.stack) >= count, f'got {len(self.stack)} items, wanted to protect {count}'
         self.protected += count
-        self._print(f' protect {count} item(s);')
+        self.print(f' protect {count} item(s);')
 
     def restore(self, count: int):
         assert self.protected >= count, f'wanted to restore {count}, only {self.protected} protected'
-        self._print(f' restore {count} item(s);')
+        self.print(f' restore {count} item(s);')
         self.protected -= count
 
     def push(self, item: StackItem, annots=None):
         assert_stack_item(item)
         self.stack.insert(self.protected, item.rename(annots))
         self.pushed = True
-        self._print(f' push {repr(item)};')
+        self.print(f' push {repr(item)};')
 
     def peek(self):
         assert len(self.stack) > 0, 'stack is empty'
@@ -92,7 +92,7 @@ def pop(self, count: int) -> List[StackItem]:
             body = ', '.join(map(repr, res))  # TODO: restrict line length
         else:
             body = f'{count} items'
-        self._print(f' pop {body};')
+        self.print(f' pop {body};')
         return res
 
     def pop1(self):
@@ -114,25 +114,24 @@ def set(self, key, value):
             val = micheline_to_michelson(value, inline=True)
         else:
             val = repr(value)
-        self._print(f' set {key}={val};')
+        self.print(f' set {key}={val};')
 
     def unset(self, key):
-        del self.meta[key]
-        self._print(f' unset {key};')
+        if key in self.meta:
+            del self.meta[key]
+            self.print(f' unset {key};')
 
     def drop_all(self):
         self.stack.clear()
         self.protected = 0
-        self._print(f' drop all;')
+        self.print(f' drop all;')
 
     def dump(self, count: int):
         if len(self.stack) > 0:
             count = min(count, len(self.stack))
             return self.stack[:count]
-        else:
-            return 'stack is empty'
 
-    def _print(self, message):
+    def print(self, message):
         if self.debug:
             self.stdout.append(message)
 
@@ -143,13 +142,14 @@ def format_stack_item(match):
             return repr(self.stack[i])
 
         message = re.sub(r'\{(\d+)\}', format_stack_item, template)
-        self.stdout.append(message)
+        indent = '  ' * (self.exec_depth - 1)
+        self.stdout.append(f'\n{indent}PRINT: {message};')
 
     def begin(self, prim=None):
         self.pushed = False
         if prim:
             indent = '  ' * self.exec_depth
-            self._print(f'\n{indent}{prim}:')
+            self.print(f'\n{indent}{prim}:')
         self.exec_depth += 1
 
     def end(self):
diff --git a/pytezos/repl/control.py b/pytezos/repl/control.py
index c4be588db..91cf23ff3 100644
--- a/pytezos/repl/control.py
+++ b/pytezos/repl/control.py
@@ -75,7 +75,7 @@ def do_drop(ctx: Context, prim, args, annots):
 
 @instruction('DROP')
 def do_drop_1(ctx: Context, prim, args, annots):
-    return do_drop(ctx, prim, [{'int': '1'}], annots)
+    do_drop(ctx, prim, [{'int': '1'}], annots)
 
 
 @instruction('DUP')
@@ -123,7 +123,7 @@ def do_dip(ctx: Context, prim, args, annots):
 
 @instruction('DIP', args_len=1)
 def do_dip_1(ctx: Context, prim, args, annots):
-    return do_dip(ctx, prim, [{'int': '1'}, args[0]], annots)
+    do_dip(ctx, prim, [{'int': '1'}, args[0]], annots)
 
 
 @instruction('LAMBDA', args_len=3)
diff --git a/pytezos/repl/helpers.py b/pytezos/repl/helpers.py
index e1635c1d8..390c83177 100644
--- a/pytezos/repl/helpers.py
+++ b/pytezos/repl/helpers.py
@@ -2,11 +2,10 @@
 
 from pytezos import Contract, pytezos
 from pytezos.encoding import is_kt
-from pytezos.michelson.converter import micheline_to_michelson
 from pytezos.repl.control import instruction, do_interpret
 from pytezos.repl.context import Context
 from pytezos.repl.parser import get_int, get_string, get_bool, parse_prim_expr, get_entry_expr, assert_expr_equal
-from pytezos.repl.types import Pair, Mutez, Address, ChainID, Timestamp, assert_stack_type, List
+from pytezos.repl.types import Pair, Mutez, Address, ChainID, Timestamp, assert_stack_type, List, Operation
 
 helpers_prim = ['DUMP', 'PRINT', 'DROP_ALL', 'EXPAND', 'RUN', 'PATCH',
                 'INCLUDE', 'DEBUG', 'BIG_MAP_DIFF', 'BEGIN', 'COMMIT']
@@ -15,17 +14,21 @@
 
 @instruction('DUMP', args_len=1)
 def do_dump(ctx: Context, prim, args, annots):
-    return ctx.dump(count=get_int(args[0]))
+    res = ctx.dump(count=get_int(args[0]))
+    if res:
+        return {'kind': 'stack', 'stack': res}
+    else:
+        return {'kind': 'message', 'value': 'stack is empty'}
 
 
 @instruction('DUMP')
-def do_dump(ctx: Context, prim, args, annots):
-    return ctx.dump(count=len(ctx))
+def do_dump_all(ctx: Context, prim, args, annots):
+    return do_dump(ctx, prim, args=[{'int': str(len(ctx))}], annots=annots)
 
 
 @instruction('PRINT', args_len=1)
 def do_print(ctx: Context, prim, args, annots):
-    ctx.printf(template=f' {get_string(args[0])};')
+    ctx.printf(template=get_string(args[0]))
 
 
 @instruction('DEBUG', args_len=1)
@@ -40,7 +43,7 @@ def do_drop_all(ctx: Context, prim, args, annots):
 
 @instruction('EXPAND', args_len=1)
 def do_expand(ctx: Context, prim, args, annots):
-    return micheline_to_michelson(args[0])
+    return {'kind': 'code', 'code': args[0]}
 
 
 @instruction('BEGIN', args_len=2)
@@ -49,7 +52,7 @@ def do_begin(ctx: Context, prim, args, annots):
     assert p_type_expr, f'parameter type is not initialized'
 
     entrypoint = next((a for a in annots if a[0] == '%'), '%default')
-    ctx.printf(f' use {entrypoint};')
+    ctx.print(f' use {entrypoint};')
 
     p_type_expr = get_entry_expr(p_type_expr, entrypoint)
     parameter = ctx.big_maps.pre_alloc(args[0], p_type_expr, copy=True)
@@ -72,6 +75,7 @@ def do_commit(ctx: Context, prim, args, annots):
 
     operations = output.get_element(0)
     assert_stack_type(operations, List)
+    assert operations.val_type() == Operation, f'expected list of operations'
 
     s_type_expr = ctx.get('storage')
     assert s_type_expr, f'storage type is not initialized'
@@ -84,7 +88,10 @@ def do_commit(ctx: Context, prim, args, annots):
     res = Pair.new(operations, storage)
     ctx.push(res)
     ctx.debug = debug
-    return operations, storage, big_map_diff
+    return {'kind': 'output',
+            'operations': operations,
+            'storage': storage,
+            'big_map_diff': big_map_diff}
 
 
 @instruction('RUN', args_len=2)
@@ -141,4 +148,4 @@ def do_include(ctx: Context, prim, args, annots):
 def do_big_map_diff(ctx: Context, prim, args, annots):
     top = ctx.peek()
     _, big_map_diff = ctx.big_maps.diff(top)
-    return big_map_diff
+    return {'kind': 'big_map_diff', 'big_map_diff': big_map_diff}
diff --git a/pytezos/repl/interpreter.py b/pytezos/repl/interpreter.py
index aead8dece..491f4b3f8 100644
--- a/pytezos/repl/interpreter.py
+++ b/pytezos/repl/interpreter.py
@@ -1,3 +1,4 @@
+import yaml
 from copy import deepcopy
 from pprint import pformat
 
@@ -10,16 +11,74 @@
 from pytezos.repl.blockchain import *
 
 
+def get_content(item: Operation):
+    content = item.val_expr.get('_content')
+    if content:
+        return format_content(content)
+    return {}
+
+
 def format_stack_item(item: StackItem):
-    row = {
-        'value': micheline_to_michelson(item.val_expr),
-        'type': micheline_to_michelson(item.type_expr)
-    }
+    row = {}
+    if isinstance(item, Operation):
+        row['value'] = yaml.dump(get_content(item)).rstrip('\n')
+    elif isinstance(item, List) and item.val_type() == Operation:
+        row['value'] = yaml.dump([get_content(x) for x in item.val_expr]).rstrip('\n')
+    else:
+        row['value'] = micheline_to_michelson(item.val_expr)
+
+    row['type'] = micheline_to_michelson(item.type_expr)
     if item.name is not None:
-        row['name'] = item.name
+        row['name'] = f'@{item.name}'
+
     return row
 
 
+def format_diff(diff: dict):
+    if diff['action'] == 'alloc':
+        return {'big_map': diff['big_map'],
+                'action': diff['action'],
+                'key': micheline_to_michelson(diff['key_type']),
+                'value': micheline_to_michelson(diff['value_type'])}
+    elif diff['action'] == 'update':
+        return {'big_map': diff['big_map'],
+                'action': diff['action'],
+                'key': micheline_to_michelson(diff['key']),
+                'value': micheline_to_michelson(diff['value']) if diff.get('value') else 'null'}
+    elif diff['action'] == 'copy':
+        return {'destination_big_map': diff['big_map'],
+                'action': diff['action'],
+                'value': diff['source_big_map']}
+    elif diff['action'] == 'remove':
+        return {'big_map': diff['big_map'],
+                'action': diff['action']}
+    else:
+        assert False, diff['action']
+
+
+def format_content(content):
+    if content['kind'] == 'transaction':
+        return {'kind': content['kind'],
+                'target': content['destination'],
+                'amount': content['amount'],
+                'entrypoint': content['parameters']['entrypoint'],
+                'parameters': micheline_to_michelson(content['parameters']['value'])}
+    elif content['kind'] == 'origination':
+        res = {'kind': content['kind'],
+               'target': content['originated_contract'],
+               'amount': content['balance'],
+               'storage': micheline_to_michelson(content['script']['storage']),
+               'code': micheline_to_michelson(content['script']['code'])}
+        if content.get('delegate'):
+            res['delegate'] = content['delegate']
+        return res
+    elif content['kind'] == 'delegation':
+        return {'kind': content['kind'],
+                'target': content['delegate']}
+    else:
+        assert False, content['kind']
+
+
 def format_stdout(items):
     res = ''.join(items).lstrip('\n')
     return res if any(map(lambda x: x in res, ['\n', 'PRINT'])) else ''
@@ -28,12 +87,22 @@ def format_stdout(items):
 def format_result(result):
     if result is None:
         return None
-    elif isinstance(result, StackItem):
-        return [format_stack_item(result)]
-    elif isinstance(result, list):
-        if len(result) > 0 and isinstance(result[0], StackItem):
-            return list(map(format_stack_item, result))
-    return result
+    kind = result['kind']
+    if kind == 'message':
+        return result
+    elif kind == 'big_map_diff':
+        return {'value': list(map(format_diff, result['big_map_diff'])), **result}
+    elif kind == 'code':
+        return {'value': micheline_to_michelson(result['code']), **result}
+    elif kind == 'stack':
+        return {'value': list(map(format_stack_item, result['stack'])), **result}
+    elif kind == 'output':
+        operations = [format_content(x.get('_content')) for x in result['operations'].val_expr]
+        storage = [format_stack_item(result['storage'])]
+        big_map_diff = list(map(format_diff, result['big_map_diff']))
+        return {'value': (operations, storage, big_map_diff), **result}
+    else:
+        assert False, kind
 
 
 def format_stderr(error):
@@ -72,7 +141,7 @@ def execute(self, code):
         try:
             res = do_interpret(self.ctx, code_expr)
             if res is None and self.ctx.pushed:
-                res = self.ctx.dump(count=1)
+                res = {'kind': 'stack', 'stack': self.ctx.dump(count=1)}
 
             int_res['result'] = format_result(res)
             int_res['stdout'] = format_stdout(self.ctx.stdout)
@@ -92,6 +161,6 @@ def execute(self, code):
             if int_res.get('stdout'):
                 print(int_res['stdout'])
             if int_res.get('result'):
-                print('RETURN: ' + pformat(int_res['result']))
+                print('RESULT: ' + pformat(int_res['result']))
 
         return int_res
diff --git a/pytezos/repl/parser.py b/pytezos/repl/parser.py
index 585970335..38800c083 100644
--- a/pytezos/repl/parser.py
+++ b/pytezos/repl/parser.py
@@ -66,7 +66,7 @@ def get_prim_args(val_expr, prim, args_len: int):
 
 def dispatch_prim_map(val_expr, mapping: dict):
     p, args = parse_prim_expr(val_expr)
-    expected = ' or '.join(map(lambda x: f'{x[0]} ({x[1]} args)', mapping))
+    expected = ' or '.join(map(lambda x: f'{x[0]} ({x[1]} args)', mapping.items()))
     assert (p, len(args)) in mapping, f'expected {expected}, got {p} ({len(args)} args)'
     res = mapping[(p, len(args))]
     if callable(res):
@@ -107,7 +107,7 @@ def get_int(val_expr):
 
 
 def get_bool(val_expr):
-    return dispatch_prim_map(val_expr, {'True': True, 'False': False})
+    return dispatch_prim_map(val_expr, {('True', 0): True, ('False', 0): False})
 
 
 def get_bytes(val_expr):
@@ -373,8 +373,7 @@ def parse_contract(val_expr, type_expr, selector):
 
 @primitive('operation')
 def parse_operation(val_expr, type_expr, selector):
-    val = get_string(val_expr)
-    return selector(val_expr, type_expr, val)
+    return selector(val_expr, type_expr, get_string(val_expr))
 
 
 @primitive('key')
diff --git a/pytezos/repl/types.py b/pytezos/repl/types.py
index b43ed503a..f609e0487 100644
--- a/pytezos/repl/types.py
+++ b/pytezos/repl/types.py
@@ -1,5 +1,6 @@
 from pprint import pformat
 from copy import deepcopy
+import yaml
 
 from pytezos.michelson.pack import get_key_hash
 from pytezos.michelson.converter import micheline_to_michelson
@@ -16,7 +17,7 @@ def assert_stack_type(item: 'StackItem', item_type):
     if not isinstance(item_type, list):
         item_type = [item_type]
     expected = ' or '.join(map(lambda x: x.__name__, item_type))
-    assert type(item) in item_type, f'expected {expected}, got {type(item).__name__}: {item}'
+    assert type(item) in item_type, f'expected {expected}, got {type(item).__name__}'
 
 
 def dispatch_type_map(a, b, mapping):
@@ -31,9 +32,7 @@ def assert_equal_types(a, b):
 
 def get_name(annots: list, prefix, default=None):
     if isinstance(annots, list):
-        res = next((x[1:] for x in annots if x.startswith(prefix)), None)
-        if res is not None:
-            return res
+        return next((x[1:] for x in annots if x.startswith(prefix)), default)
     return default
 
 
@@ -107,7 +106,7 @@ def __len__(self):
         return len(self._val)
 
     def __repr__(self):
-        return pformat(self._val, compact=True, width=60)
+        return str(self._val)
 
     def _modify(self, cache_val=False, **kwargs):
         param = dict(
@@ -125,7 +124,7 @@ def __deepcopy__(self, memodict={}):
         return self._modify(cache_val=True)
 
     def rename(self, annots: list):
-        return self._modify(cache_val=True, name=get_name(annots, '@'))
+        return self._modify(cache_val=True, name=get_name(annots, prefix='@'))
 
 
 class String(StackItem, prim='string'):
@@ -134,7 +133,8 @@ def __init__(self, val='', val_expr=None, type_expr=None, **kwargs):
         assert isinstance(val, str)
         super(String, self).__init__(val=val if val_expr is None else parse_expression(val_expr, type_expr),
                                      val_expr=val_expr or {'string': val},
-                                     type_expr=type_expr or {'prim': self.prim})
+                                     type_expr=type_expr or {'prim': self.prim},
+                                     **kwargs)
 
     def __getitem__(self, item):
         assert_type(item, slice)
@@ -148,7 +148,8 @@ def __init__(self, val=0, val_expr=None, type_expr=None, **kwargs):
         assert isinstance(val, int)
         super(Int, self).__init__(val=val if val_expr is None else parse_expression(val_expr, type_expr),
                                   val_expr=val_expr or {'int': str(val)},
-                                  type_expr=type_expr or {'prim': self.prim})
+                                  type_expr=type_expr or {'prim': self.prim},
+                                  **kwargs)
 
 
 class Bytes(StackItem, prim='bytes'):
@@ -157,7 +158,8 @@ def __init__(self, val=b'', type_expr=None, val_expr=None, **kwargs):
         assert_type(val, bytes)
         super(Bytes, self).__init__(val=val if val_expr is None else parse_expression(val_expr, type_expr),
                                     val_expr=val_expr or {'bytes': val.hex()},
-                                    type_expr=type_expr or {'prim': self.prim})
+                                    type_expr=type_expr or {'prim': self.prim},
+                                    **kwargs)
 
     def __getitem__(self, item):
         assert_type(item, slice)
@@ -172,7 +174,7 @@ class Nat(Int, prim='nat'):
     def __init__(self, val=0, val_expr=None, type_expr=None, **kwargs):
         assert_type(val, int)
         assert val >= 0, 'expected non-negative val'
-        super(Nat, self).__init__(val=val, val_expr=val_expr, type_expr=type_expr)
+        super(Nat, self).__init__(val=val, val_expr=val_expr, type_expr=type_expr, **kwargs)
 
 
 class Bool(StackItem, prim='bool'):
@@ -181,7 +183,8 @@ def __init__(self, val=False, val_expr=None, type_expr=None, **kwargs):
         assert_type(val, bool)
         super(Bool, self).__init__(val=val if val_expr is None else parse_expression(val_expr, type_expr),
                                    val_expr=val_expr or {'prim': str(val)},
-                                   type_expr=type_expr or {'prim': self.prim})
+                                   type_expr=type_expr or {'prim': self.prim},
+                                   **kwargs)
 
 
 class Unit(StackItem, prim='unit'):
@@ -189,7 +192,8 @@ class Unit(StackItem, prim='unit'):
     def __init__(self, val=UnitNone(), val_expr=None, type_expr=None, **kwargs):
         super(Unit, self).__init__(val=val if val_expr is None else parse_expression(val_expr, type_expr),
                                    val_expr=val_expr or {'prim': 'Unit'},
-                                   type_expr=type_expr or {'prim': self.prim})
+                                   type_expr=type_expr or {'prim': self.prim},
+                                   **kwargs)
 
 
 class List(StackItem, prim='list', args_len=1):
@@ -452,7 +456,7 @@ class Mutez(Nat, prim='mutez'):
     def __init__(self, val=0, val_expr=None, type_expr=None, **kwargs):
         assert_type(val, int)
         assert val.bit_length() <= 63, f'mutez overflow, got {val.bit_length()} bits, should not exceed 63'
-        super(Mutez, self).__init__(val=val, val_expr=val_expr, type_expr=type_expr)
+        super(Mutez, self).__init__(val=val, val_expr=val_expr, type_expr=type_expr, **kwargs)
 
 
 class Address(String, prim='address'):
@@ -510,7 +514,7 @@ class ChainID(String, prim='chain_id'):
 
     def __init__(self, val, val_expr=None, type_expr=None, **kwargs):
         assert is_chain_id(val), f'expected chain_id, got {val}'
-        super(ChainID, self).__init__(val, val_expr=val_expr, type_expr=type_expr)
+        super(ChainID, self).__init__(val, val_expr=val_expr, type_expr=type_expr, **kwargs)
 
 
 class Lambda(StackItem, prim='lambda', args_len=2):
@@ -558,7 +562,7 @@ def format_content(content):
             else:
                 return f'<call {content["destination"]}%{content["parameters"]["entrypoint"]}>'
         elif content['kind'] == 'origination':
-            return f'<originate contract>'
+            return f'<originate {content["originated_contract"]}>'
         elif content['kind'] == 'delegation':
             if content.get('delegate'):
                 return f'<delegate to {content["delegate"]}>'
@@ -570,5 +574,5 @@ def format_content(content):
     @classmethod
     def new(cls, content):
         return cls(val=cls.format_content(content),
-                   val_expr={'string': str(content), '_content': content},
-                   type_expr={'prim': cls.prim, 'annots': [f':{content["kind"]}']})
+                   val_expr={'string': cls.format_content(content), '_content': content},
+                   type_expr={'prim': cls.prim})
diff --git a/tests/opcodes/cases/test_abs_187.py b/tests/opcodes/cases/test_abs_187.py
index 350330bff..6f47cf673 100644
--- a/tests/opcodes/cases/test_abs_187.py
+++ b/tests/opcodes/cases/test_abs_187.py
@@ -20,6 +20,6 @@ def test_opcode_abs_187(self):
         res = self.i.execute('RUN 12039123919239192312931 Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_abs_188.py b/tests/opcodes/cases/test_abs_188.py
index fd4b7c925..10fc2bc3c 100644
--- a/tests/opcodes/cases/test_abs_188.py
+++ b/tests/opcodes/cases/test_abs_188.py
@@ -20,6 +20,6 @@ def test_opcode_abs_188(self):
         res = self.i.execute('RUN 0 Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_abs_189.py b/tests/opcodes/cases/test_abs_189.py
index b8d068117..4ec7c140f 100644
--- a/tests/opcodes/cases/test_abs_189.py
+++ b/tests/opcodes/cases/test_abs_189.py
@@ -20,6 +20,6 @@ def test_opcode_abs_189(self):
         res = self.i.execute('RUN 948 Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_186.py b/tests/opcodes/cases/test_add_186.py
index a472cb566..34ed59b51 100644
--- a/tests/opcodes/cases/test_add_186.py
+++ b/tests/opcodes/cases/test_add_186.py
@@ -20,6 +20,6 @@ def test_opcode_add_186(self):
         res = self.i.execute('RUN Unit Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_delta_timestamp_212.py b/tests/opcodes/cases/test_add_delta_timestamp_212.py
index 1a6c77ac8..6af36010f 100644
--- a/tests/opcodes/cases/test_add_delta_timestamp_212.py
+++ b/tests/opcodes/cases/test_add_delta_timestamp_212.py
@@ -20,6 +20,6 @@ def test_opcode_add_delta_timestamp_212(self):
         res = self.i.execute('RUN (Pair 100 100) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:03:20Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:03:20Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_delta_timestamp_213.py b/tests/opcodes/cases/test_add_delta_timestamp_213.py
index 554968041..b1b8dbd3e 100644
--- a/tests/opcodes/cases/test_add_delta_timestamp_213.py
+++ b/tests/opcodes/cases/test_add_delta_timestamp_213.py
@@ -20,6 +20,6 @@ def test_opcode_add_delta_timestamp_213(self):
         res = self.i.execute('RUN (Pair -100 100) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_delta_timestamp_214.py b/tests/opcodes/cases/test_add_delta_timestamp_214.py
index fe07a7cee..5019d9a8f 100644
--- a/tests/opcodes/cases/test_add_delta_timestamp_214.py
+++ b/tests/opcodes/cases/test_add_delta_timestamp_214.py
@@ -20,6 +20,6 @@ def test_opcode_add_delta_timestamp_214(self):
         res = self.i.execute('RUN (Pair 0 "1970-01-01T00:00:00Z") None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_timestamp_delta_209.py b/tests/opcodes/cases/test_add_timestamp_delta_209.py
index 273731f41..84bb36c33 100644
--- a/tests/opcodes/cases/test_add_timestamp_delta_209.py
+++ b/tests/opcodes/cases/test_add_timestamp_delta_209.py
@@ -20,6 +20,6 @@ def test_opcode_add_timestamp_delta_209(self):
         res = self.i.execute('RUN (Pair 100 100) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:03:20Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:03:20Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_timestamp_delta_210.py b/tests/opcodes/cases/test_add_timestamp_delta_210.py
index 575638cc1..671cf43f3 100644
--- a/tests/opcodes/cases/test_add_timestamp_delta_210.py
+++ b/tests/opcodes/cases/test_add_timestamp_delta_210.py
@@ -20,6 +20,6 @@ def test_opcode_add_timestamp_delta_210(self):
         res = self.i.execute('RUN (Pair 100 -100) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_add_timestamp_delta_211.py b/tests/opcodes/cases/test_add_timestamp_delta_211.py
index 9fb724562..20d2a34db 100644
--- a/tests/opcodes/cases/test_add_timestamp_delta_211.py
+++ b/tests/opcodes/cases/test_add_timestamp_delta_211.py
@@ -20,6 +20,6 @@ def test_opcode_add_timestamp_delta_211(self):
         res = self.i.execute('RUN (Pair "1970-01-01T00:00:00Z" 0) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "1970-01-01T00:00:00Z")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_address_238.py b/tests/opcodes/cases/test_address_238.py
index 176577532..fd7e5b72e 100644
--- a/tests/opcodes/cases/test_address_238.py
+++ b/tests/opcodes/cases/test_address_238.py
@@ -20,6 +20,6 @@ def test_opcode_address_238(self):
         res = self.i.execute('RUN "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5" None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_36.py b/tests/opcodes/cases/test_and_36.py
index 50f83e5e9..258c4f86b 100644
--- a/tests/opcodes/cases/test_and_36.py
+++ b/tests/opcodes/cases/test_and_36.py
@@ -20,6 +20,6 @@ def test_opcode_and_36(self):
         res = self.i.execute('RUN (Pair False False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_37.py b/tests/opcodes/cases/test_and_37.py
index aceb15744..eafc724e1 100644
--- a/tests/opcodes/cases/test_and_37.py
+++ b/tests/opcodes/cases/test_and_37.py
@@ -20,6 +20,6 @@ def test_opcode_and_37(self):
         res = self.i.execute('RUN (Pair False True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_38.py b/tests/opcodes/cases/test_and_38.py
index b24ef83eb..a01280b77 100644
--- a/tests/opcodes/cases/test_and_38.py
+++ b/tests/opcodes/cases/test_and_38.py
@@ -20,6 +20,6 @@ def test_opcode_and_38(self):
         res = self.i.execute('RUN (Pair True False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_39.py b/tests/opcodes/cases/test_and_39.py
index 00e100448..bace060fb 100644
--- a/tests/opcodes/cases/test_and_39.py
+++ b/tests/opcodes/cases/test_and_39.py
@@ -20,6 +20,6 @@ def test_opcode_and_39(self):
         res = self.i.execute('RUN (Pair True True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_binary_48.py b/tests/opcodes/cases/test_and_binary_48.py
index f70540676..46dedcc07 100644
--- a/tests/opcodes/cases/test_and_binary_48.py
+++ b/tests/opcodes/cases/test_and_binary_48.py
@@ -20,6 +20,6 @@ def test_opcode_and_binary_48(self):
         res = self.i.execute('RUN Unit Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_logical_1_44.py b/tests/opcodes/cases/test_and_logical_1_44.py
index dd66a0e23..85f886ea3 100644
--- a/tests/opcodes/cases/test_and_logical_1_44.py
+++ b/tests/opcodes/cases/test_and_logical_1_44.py
@@ -20,6 +20,6 @@ def test_opcode_and_logical_1_44(self):
         res = self.i.execute('RUN (Pair False False) False')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('False')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('False')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_logical_1_45.py b/tests/opcodes/cases/test_and_logical_1_45.py
index eeacc57c1..7c4441385 100644
--- a/tests/opcodes/cases/test_and_logical_1_45.py
+++ b/tests/opcodes/cases/test_and_logical_1_45.py
@@ -20,6 +20,6 @@ def test_opcode_and_logical_1_45(self):
         res = self.i.execute('RUN (Pair False True) False')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('False')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('False')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_logical_1_46.py b/tests/opcodes/cases/test_and_logical_1_46.py
index 92b76719f..d98ffd5ff 100644
--- a/tests/opcodes/cases/test_and_logical_1_46.py
+++ b/tests/opcodes/cases/test_and_logical_1_46.py
@@ -20,6 +20,6 @@ def test_opcode_and_logical_1_46(self):
         res = self.i.execute('RUN (Pair True False) False')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('False')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('False')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_and_logical_1_47.py b/tests/opcodes/cases/test_and_logical_1_47.py
index e15f2ba8e..64fb9307d 100644
--- a/tests/opcodes/cases/test_and_logical_1_47.py
+++ b/tests/opcodes/cases/test_and_logical_1_47.py
@@ -20,6 +20,6 @@ def test_opcode_and_logical_1_47(self):
         res = self.i.execute('RUN (Pair True True) False')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('True')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('True')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_272.py b/tests/opcodes/cases/test_assert_272.py
index 7e7b57aa5..2306323c1 100644
--- a/tests/opcodes/cases/test_assert_272.py
+++ b/tests/opcodes/cases/test_assert_272.py
@@ -20,6 +20,6 @@ def test_opcode_assert_272(self):
         res = self.i.execute('RUN True Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmpeq_282.py b/tests/opcodes/cases/test_assert_cmpeq_282.py
index 195530b7c..6f9fd0cd0 100644
--- a/tests/opcodes/cases/test_assert_cmpeq_282.py
+++ b/tests/opcodes/cases/test_assert_cmpeq_282.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmpeq_282(self):
         res = self.i.execute('RUN (Pair -1 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmpge_288.py b/tests/opcodes/cases/test_assert_cmpge_288.py
index 63c3eb5a3..debdc016d 100644
--- a/tests/opcodes/cases/test_assert_cmpge_288.py
+++ b/tests/opcodes/cases/test_assert_cmpge_288.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmpge_288(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmpge_289.py b/tests/opcodes/cases/test_assert_cmpge_289.py
index cbc19dc07..4e228ad10 100644
--- a/tests/opcodes/cases/test_assert_cmpge_289.py
+++ b/tests/opcodes/cases/test_assert_cmpge_289.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmpge_289(self):
         res = self.i.execute('RUN (Pair 0 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmpgt_287.py b/tests/opcodes/cases/test_assert_cmpgt_287.py
index 8ba953c2f..b3b61e39d 100644
--- a/tests/opcodes/cases/test_assert_cmpgt_287.py
+++ b/tests/opcodes/cases/test_assert_cmpgt_287.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmpgt_287(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmple_285.py b/tests/opcodes/cases/test_assert_cmple_285.py
index f6939c2f0..401048fc1 100644
--- a/tests/opcodes/cases/test_assert_cmple_285.py
+++ b/tests/opcodes/cases/test_assert_cmple_285.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmple_285(self):
         res = self.i.execute('RUN (Pair -1 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmple_286.py b/tests/opcodes/cases/test_assert_cmple_286.py
index 7810d5119..4934b8dd3 100644
--- a/tests/opcodes/cases/test_assert_cmple_286.py
+++ b/tests/opcodes/cases/test_assert_cmple_286.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmple_286(self):
         res = self.i.execute('RUN (Pair 0 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmplt_284.py b/tests/opcodes/cases/test_assert_cmplt_284.py
index 7644e07d4..b68ed14b5 100644
--- a/tests/opcodes/cases/test_assert_cmplt_284.py
+++ b/tests/opcodes/cases/test_assert_cmplt_284.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmplt_284(self):
         res = self.i.execute('RUN (Pair -1 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_cmpneq_283.py b/tests/opcodes/cases/test_assert_cmpneq_283.py
index c53044bf6..20c625444 100644
--- a/tests/opcodes/cases/test_assert_cmpneq_283.py
+++ b/tests/opcodes/cases/test_assert_cmpneq_283.py
@@ -20,6 +20,6 @@ def test_opcode_assert_cmpneq_283(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_eq_273.py b/tests/opcodes/cases/test_assert_eq_273.py
index 66425b8f3..fe8ebcd93 100644
--- a/tests/opcodes/cases/test_assert_eq_273.py
+++ b/tests/opcodes/cases/test_assert_eq_273.py
@@ -20,6 +20,6 @@ def test_opcode_assert_eq_273(self):
         res = self.i.execute('RUN (Pair -1 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_eq_274.py b/tests/opcodes/cases/test_assert_eq_274.py
index 83458acce..99cb53a04 100644
--- a/tests/opcodes/cases/test_assert_eq_274.py
+++ b/tests/opcodes/cases/test_assert_eq_274.py
@@ -20,6 +20,6 @@ def test_opcode_assert_eq_274(self):
         res = self.i.execute('RUN (Pair -1 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_ge_280.py b/tests/opcodes/cases/test_assert_ge_280.py
index 7ab00cdcb..7b1b04dd2 100644
--- a/tests/opcodes/cases/test_assert_ge_280.py
+++ b/tests/opcodes/cases/test_assert_ge_280.py
@@ -20,6 +20,6 @@ def test_opcode_assert_ge_280(self):
         res = self.i.execute('RUN (Pair 0 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_ge_281.py b/tests/opcodes/cases/test_assert_ge_281.py
index 537cf24d1..b5d47ca37 100644
--- a/tests/opcodes/cases/test_assert_ge_281.py
+++ b/tests/opcodes/cases/test_assert_ge_281.py
@@ -20,6 +20,6 @@ def test_opcode_assert_ge_281(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_gt_279.py b/tests/opcodes/cases/test_assert_gt_279.py
index 304bd0a97..4b4953336 100644
--- a/tests/opcodes/cases/test_assert_gt_279.py
+++ b/tests/opcodes/cases/test_assert_gt_279.py
@@ -20,6 +20,6 @@ def test_opcode_assert_gt_279(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_le_277.py b/tests/opcodes/cases/test_assert_le_277.py
index 604311b17..1f2469134 100644
--- a/tests/opcodes/cases/test_assert_le_277.py
+++ b/tests/opcodes/cases/test_assert_le_277.py
@@ -20,6 +20,6 @@ def test_opcode_assert_le_277(self):
         res = self.i.execute('RUN (Pair 0 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_le_278.py b/tests/opcodes/cases/test_assert_le_278.py
index 6d095fd86..a2f789dac 100644
--- a/tests/opcodes/cases/test_assert_le_278.py
+++ b/tests/opcodes/cases/test_assert_le_278.py
@@ -20,6 +20,6 @@ def test_opcode_assert_le_278(self):
         res = self.i.execute('RUN (Pair -1 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_lt_276.py b/tests/opcodes/cases/test_assert_lt_276.py
index fbf8d9cb1..0cb0b5df5 100644
--- a/tests/opcodes/cases/test_assert_lt_276.py
+++ b/tests/opcodes/cases/test_assert_lt_276.py
@@ -20,6 +20,6 @@ def test_opcode_assert_lt_276(self):
         res = self.i.execute('RUN (Pair -1 0) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_assert_neq_275.py b/tests/opcodes/cases/test_assert_neq_275.py
index da756b42f..50cfce7a6 100644
--- a/tests/opcodes/cases/test_assert_neq_275.py
+++ b/tests/opcodes/cases/test_assert_neq_275.py
@@ -20,6 +20,6 @@ def test_opcode_assert_neq_275(self):
         res = self.i.execute('RUN (Pair 0 -1) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_balance_183.py b/tests/opcodes/cases/test_balance_183.py
index c5289283e..9919062e9 100644
--- a/tests/opcodes/cases/test_balance_183.py
+++ b/tests/opcodes/cases/test_balance_183.py
@@ -20,6 +20,6 @@ def test_opcode_balance_183(self):
         res = self.i.execute('RUN Unit 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('257000000')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('257000000')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_magic_10.py b/tests/opcodes/cases/test_big_map_magic_10.py
index e24a47fbe..b165304e2 100644
--- a/tests/opcodes/cases/test_big_map_magic_10.py
+++ b/tests/opcodes/cases/test_big_map_magic_10.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_10(self):
         res = self.i.execute('RUN (Right (Left (Left (Pair { Elt "3" "three" } { Elt "4" "four" })))) (Left (Pair { Elt "1" "one" } { Elt "2" "two" }))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Pair 0 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Pair 0 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '1', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '1', 'key_hash': 'exprttiwE7dpYJ8Xjp28uMZzcC3Bwh4xAEF7GT7FutVwVoskMZYExx', 'key': {'string': '4'}, 'value': {'string': 'four'}}, {'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtzN2y9qBiaf7A14AbS1SveJWXpMdJQztXFgiGzG5yu43tem2he', 'key': {'string': '3'}, 'value': {'string': 'three'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_magic_11.py b/tests/opcodes/cases/test_big_map_magic_11.py
index 821688cee..d71fd05af 100644
--- a/tests/opcodes/cases/test_big_map_magic_11.py
+++ b/tests/opcodes/cases/test_big_map_magic_11.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_11(self):
         res = self.i.execute('RUN (Right (Left (Right Unit))) (Left (Pair { Elt "1" "one" } { Elt "2" "two" }))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = []
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_magic_12.py b/tests/opcodes/cases/test_big_map_magic_12.py
index 0e581e35f..af88d5076 100644
--- a/tests/opcodes/cases/test_big_map_magic_12.py
+++ b/tests/opcodes/cases/test_big_map_magic_12.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_12(self):
         res = self.i.execute('RUN (Right (Right (Left (Pair { Pair "foo" "bar" } { Pair "gaz" "baz" }) ))) (Right Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Pair 0 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Pair 0 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '1', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '1', 'key_hash': 'exprtft4mfpxnyufwZf17PQxf57VAyrwNM5mNwqCMkVRTfb5pALQpz', 'key': {'string': 'gaz'}, 'value': {'string': 'baz'}}, {'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'expruTFUPVsqkuD5iwLMJuzoyGSFABnxLo7CZrgnS1czt1WbTwpVrJ', 'key': {'string': 'foo'}, 'value': {'string': 'bar'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_magic_13.py b/tests/opcodes/cases/test_big_map_magic_13.py
index 4916895dd..8dd86e67b 100644
--- a/tests/opcodes/cases/test_big_map_magic_13.py
+++ b/tests/opcodes/cases/test_big_map_magic_13.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_13(self):
         res = self.i.execute('RUN (Right (Right (Right (Left { Pair "3" "three" })))) (Left (Pair { Elt "1" "one" } { Elt "2" "two" }) )')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Pair 0 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Pair 0 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '1', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '1', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}, {'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtzN2y9qBiaf7A14AbS1SveJWXpMdJQztXFgiGzG5yu43tem2he', 'key': {'string': '3'}, 'value': {'string': 'three'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_magic_14.py b/tests/opcodes/cases/test_big_map_magic_14.py
index 49d8328c1..3d2257e04 100644
--- a/tests/opcodes/cases/test_big_map_magic_14.py
+++ b/tests/opcodes/cases/test_big_map_magic_14.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_14(self):
         res = self.i.execute('RUN (Right (Right (Right (Right { "1" })))) (Left (Pair { Elt "1" "one" } { Elt "2" "two" }))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Pair 0 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Pair 0 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '1', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '1', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}, {'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_magic_9.py b/tests/opcodes/cases/test_big_map_magic_9.py
index a92a7a520..a385fa170 100644
--- a/tests/opcodes/cases/test_big_map_magic_9.py
+++ b/tests/opcodes/cases/test_big_map_magic_9.py
@@ -20,9 +20,9 @@ def test_opcode_big_map_magic_9(self):
         res = self.i.execute('RUN (Left Unit) (Left (Pair { Elt "1" "one" } { Elt "2" "two" }))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Pair 0 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Pair 0 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '1', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '1', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_113.py b/tests/opcodes/cases/test_big_map_mem_nat_113.py
index 5c1a7f259..83b772f3d 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_113.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_113.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_113(self):
         res = self.i.execute('RUN 1 (Pair { Elt 0 1 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_114.py b/tests/opcodes/cases/test_big_map_mem_nat_114.py
index afe5aa8d0..1146e0a05 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_114.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_114.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_114(self):
         res = self.i.execute('RUN 1 (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_115.py b/tests/opcodes/cases/test_big_map_mem_nat_115.py
index 906765e14..4e3aa2379 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_115.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_115.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_115(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 0 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_116.py b/tests/opcodes/cases/test_big_map_mem_nat_116.py
index a8405a14a..f4d39f15a 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_116.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_116.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_116(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_117.py b/tests/opcodes/cases/test_big_map_mem_nat_117.py
index 31b46ea5d..77f555b25 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_117.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_117.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_117(self):
         res = self.i.execute('RUN 2 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_118.py b/tests/opcodes/cases/test_big_map_mem_nat_118.py
index 84d4f0bab..910ab376f 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_118.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_118.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_118(self):
         res = self.i.execute('RUN 3 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_125.py b/tests/opcodes/cases/test_big_map_mem_nat_125.py
index a6a0c1a64..56ef9c9c3 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_125.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_125.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_125(self):
         res = self.i.execute('RUN 1 (Pair { Elt 0 1 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_126.py b/tests/opcodes/cases/test_big_map_mem_nat_126.py
index ea94d7d41..f959e1b72 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_126.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_126.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_126(self):
         res = self.i.execute('RUN 1 (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_127.py b/tests/opcodes/cases/test_big_map_mem_nat_127.py
index fc85e3437..6fac93c45 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_127.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_127.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_127(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 0 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_128.py b/tests/opcodes/cases/test_big_map_mem_nat_128.py
index c3eb710c1..d0ce0e46c 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_128.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_128.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_128(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_129.py b/tests/opcodes/cases/test_big_map_mem_nat_129.py
index 7ce505f55..717e56b16 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_129.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_129.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_129(self):
         res = self.i.execute('RUN 2 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_nat_130.py b/tests/opcodes/cases/test_big_map_mem_nat_130.py
index 2ddb29d1d..4ec40e685 100644
--- a/tests/opcodes/cases/test_big_map_mem_nat_130.py
+++ b/tests/opcodes/cases/test_big_map_mem_nat_130.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_nat_130(self):
         res = self.i.execute('RUN 3 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_119.py b/tests/opcodes/cases/test_big_map_mem_string_119.py
index fcb56fa7f..e8fd390df 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_119.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_119.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_119(self):
         res = self.i.execute('RUN "bar" (Pair { Elt "foo" 1 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_120.py b/tests/opcodes/cases/test_big_map_mem_string_120.py
index be30032d9..d7a643d74 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_120.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_120.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_120(self):
         res = self.i.execute('RUN "bar" (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_121.py b/tests/opcodes/cases/test_big_map_mem_string_121.py
index 76fd79411..3e1e56e2a 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_121.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_121.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_121(self):
         res = self.i.execute('RUN "foo" (Pair { Elt "foo" 0 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_122.py b/tests/opcodes/cases/test_big_map_mem_string_122.py
index cb40fea84..6578e0e3e 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_122.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_122.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_122(self):
         res = self.i.execute('RUN "foo" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_123.py b/tests/opcodes/cases/test_big_map_mem_string_123.py
index 41d12bd8f..83012be08 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_123.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_123.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_123(self):
         res = self.i.execute('RUN "bar" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_big_map_mem_string_124.py b/tests/opcodes/cases/test_big_map_mem_string_124.py
index 882f19b1d..d6083d71d 100644
--- a/tests/opcodes/cases/test_big_map_mem_string_124.py
+++ b/tests/opcodes/cases/test_big_map_mem_string_124.py
@@ -20,6 +20,6 @@ def test_opcode_big_map_mem_string_124(self):
         res = self.i.execute('RUN "baz" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_build_list_260.py b/tests/opcodes/cases/test_build_list_260.py
index bd7676cf4..465da9d02 100644
--- a/tests/opcodes/cases/test_build_list_260.py
+++ b/tests/opcodes/cases/test_build_list_260.py
@@ -20,6 +20,6 @@ def test_opcode_build_list_260(self):
         res = self.i.execute('RUN 0 {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_build_list_261.py b/tests/opcodes/cases/test_build_list_261.py
index 25c62667f..81e682c8b 100644
--- a/tests/opcodes/cases/test_build_list_261.py
+++ b/tests/opcodes/cases/test_build_list_261.py
@@ -20,6 +20,6 @@ def test_opcode_build_list_261(self):
         res = self.i.execute('RUN 3 {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0 ; 1 ; 2 ; 3 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0 ; 1 ; 2 ; 3 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_build_list_262.py b/tests/opcodes/cases/test_build_list_262.py
index 4b13deb6d..5d93bddf7 100644
--- a/tests/opcodes/cases/test_build_list_262.py
+++ b/tests/opcodes/cases/test_build_list_262.py
@@ -20,6 +20,6 @@ def test_opcode_build_list_262(self):
         res = self.i.execute('RUN 10 {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ; 10 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ; 10 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_car_32.py b/tests/opcodes/cases/test_car_32.py
index d2ddc698e..bc1838b76 100644
--- a/tests/opcodes/cases/test_car_32.py
+++ b/tests/opcodes/cases/test_car_32.py
@@ -20,6 +20,6 @@ def test_opcode_car_32(self):
         res = self.i.execute('RUN (Pair 34 17) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('34')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('34')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_cdr_33.py b/tests/opcodes/cases/test_cdr_33.py
index 9e691bfbe..e9b80398c 100644
--- a/tests/opcodes/cases/test_cdr_33.py
+++ b/tests/opcodes/cases/test_cdr_33.py
@@ -20,6 +20,6 @@ def test_opcode_cdr_33(self):
         res = self.i.execute('RUN (Pair 34 17) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('17')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('17')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_chain_id_store_255.py b/tests/opcodes/cases/test_chain_id_store_255.py
index e6f50df3a..7232c6454 100644
--- a/tests/opcodes/cases/test_chain_id_store_255.py
+++ b/tests/opcodes/cases/test_chain_id_store_255.py
@@ -20,6 +20,6 @@ def test_opcode_chain_id_store_255(self):
         res = self.i.execute('RUN Unit None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0x7a06a770)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0x7a06a770)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_compare_236.py b/tests/opcodes/cases/test_compare_236.py
index bd3c393cb..8b832b507 100644
--- a/tests/opcodes/cases/test_compare_236.py
+++ b/tests/opcodes/cases/test_compare_236.py
@@ -20,6 +20,6 @@ def test_opcode_compare_236(self):
         res = self.i.execute('RUN Unit Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_compare_bytes_292.py b/tests/opcodes/cases/test_compare_bytes_292.py
index 40d153d57..b0e432604 100644
--- a/tests/opcodes/cases/test_compare_bytes_292.py
+++ b/tests/opcodes/cases/test_compare_bytes_292.py
@@ -20,6 +20,6 @@ def test_opcode_compare_bytes_292(self):
         res = self.i.execute('RUN (Pair 0x33 0x34) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_compare_bytes_293.py b/tests/opcodes/cases/test_compare_bytes_293.py
index dc9848d5c..458813e38 100644
--- a/tests/opcodes/cases/test_compare_bytes_293.py
+++ b/tests/opcodes/cases/test_compare_bytes_293.py
@@ -20,6 +20,6 @@ def test_opcode_compare_bytes_293(self):
         res = self.i.execute('RUN (Pair 0x33 0x33aa) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_compare_bytes_294.py b/tests/opcodes/cases/test_compare_bytes_294.py
index 0c0edce41..81d2eea32 100644
--- a/tests/opcodes/cases/test_compare_bytes_294.py
+++ b/tests/opcodes/cases/test_compare_bytes_294.py
@@ -20,6 +20,6 @@ def test_opcode_compare_bytes_294(self):
         res = self.i.execute('RUN (Pair 0x33 0x33) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ True ; False ; False ; True ; True }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ True ; False ; False ; True ; True }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_compare_bytes_295.py b/tests/opcodes/cases/test_compare_bytes_295.py
index fa1f6ca8b..2cd1dd987 100644
--- a/tests/opcodes/cases/test_compare_bytes_295.py
+++ b/tests/opcodes/cases/test_compare_bytes_295.py
@@ -20,6 +20,6 @@ def test_opcode_compare_bytes_295(self):
         res = self.i.execute('RUN (Pair 0x34 0x33) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ False ; True ; False ; True ; False }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ False ; True ; False ; True ; False }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_comparisons_237.py b/tests/opcodes/cases/test_comparisons_237.py
index cdd3e7056..5e5d0c786 100644
--- a/tests/opcodes/cases/test_comparisons_237.py
+++ b/tests/opcodes/cases/test_comparisons_237.py
@@ -20,6 +20,6 @@ def test_opcode_comparisons_237(self):
         res = self.i.execute('RUN { -9999999; -1 ; 0 ; 1 ; 9999999 } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ { False ; False ; False ; True ; True } ;     { False ; False ; True ; True ; True } ;     { True ; True ; False ; False ; False } ;     { True ; True ; True ; False ; False } ;     { True ; True ; False ; True ; True } ;     { False ; False ; True ; False ; False } }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ { False ; False ; False ; True ; True } ;     { False ; False ; True ; True ; True } ;     { True ; True ; False ; False ; False } ;     { True ; True ; True ; False ; False } ;     { True ; True ; False ; True ; True } ;     { False ; False ; True ; False ; False } }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_166.py b/tests/opcodes/cases/test_concat_hello_166.py
index 0f0bb8550..710d3f518 100644
--- a/tests/opcodes/cases/test_concat_hello_166.py
+++ b/tests/opcodes/cases/test_concat_hello_166.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_166(self):
         res = self.i.execute('RUN { "World!" } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "Hello World!" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "Hello World!" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_167.py b/tests/opcodes/cases/test_concat_hello_167.py
index 82e559247..e185f8e29 100644
--- a/tests/opcodes/cases/test_concat_hello_167.py
+++ b/tests/opcodes/cases/test_concat_hello_167.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_167(self):
         res = self.i.execute('RUN {} {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_168.py b/tests/opcodes/cases/test_concat_hello_168.py
index c0d99b9a6..f6f68aab2 100644
--- a/tests/opcodes/cases/test_concat_hello_168.py
+++ b/tests/opcodes/cases/test_concat_hello_168.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_168(self):
         res = self.i.execute('RUN { "test1" ; "test2" } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "Hello test1" ; "Hello test2" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "Hello test1" ; "Hello test2" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_bytes_86.py b/tests/opcodes/cases/test_concat_hello_bytes_86.py
index 3d47a39f5..23de72c14 100644
--- a/tests/opcodes/cases/test_concat_hello_bytes_86.py
+++ b/tests/opcodes/cases/test_concat_hello_bytes_86.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_bytes_86(self):
         res = self.i.execute('RUN { 0xcd } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0xffcd }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0xffcd }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_bytes_87.py b/tests/opcodes/cases/test_concat_hello_bytes_87.py
index a394049eb..1767d9a6b 100644
--- a/tests/opcodes/cases/test_concat_hello_bytes_87.py
+++ b/tests/opcodes/cases/test_concat_hello_bytes_87.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_bytes_87(self):
         res = self.i.execute('RUN {} {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_hello_bytes_88.py b/tests/opcodes/cases/test_concat_hello_bytes_88.py
index 634345ce9..ef73c6850 100644
--- a/tests/opcodes/cases/test_concat_hello_bytes_88.py
+++ b/tests/opcodes/cases/test_concat_hello_bytes_88.py
@@ -20,6 +20,6 @@ def test_opcode_concat_hello_bytes_88(self):
         res = self.i.execute('RUN { 0xab ; 0xcd } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0xffab ; 0xffcd }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0xffab ; 0xffcd }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_list_83.py b/tests/opcodes/cases/test_concat_list_83.py
index 3b29a6058..d5211bdc0 100644
--- a/tests/opcodes/cases/test_concat_list_83.py
+++ b/tests/opcodes/cases/test_concat_list_83.py
@@ -20,6 +20,6 @@ def test_opcode_concat_list_83(self):
         res = self.i.execute('RUN { "a" ; "b" ; "c" } ""')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"abc"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"abc"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_list_84.py b/tests/opcodes/cases/test_concat_list_84.py
index abc83497b..de96094d7 100644
--- a/tests/opcodes/cases/test_concat_list_84.py
+++ b/tests/opcodes/cases/test_concat_list_84.py
@@ -20,6 +20,6 @@ def test_opcode_concat_list_84(self):
         res = self.i.execute('RUN {} ""')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('""')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('""')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_concat_list_85.py b/tests/opcodes/cases/test_concat_list_85.py
index 776491a9e..1f54cf291 100644
--- a/tests/opcodes/cases/test_concat_list_85.py
+++ b/tests/opcodes/cases/test_concat_list_85.py
@@ -20,6 +20,6 @@ def test_opcode_concat_list_85(self):
         res = self.i.execute('RUN { "Hello" ; " " ; "World" ; "!" } ""')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"Hello World!"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"Hello World!"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_cons_0.py b/tests/opcodes/cases/test_cons_0.py
index 4db05f35a..627369861 100644
--- a/tests/opcodes/cases/test_cons_0.py
+++ b/tests/opcodes/cases/test_cons_0.py
@@ -20,6 +20,6 @@ def test_opcode_cons_0(self):
         res = self.i.execute('RUN 10 {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 10 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 10 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_cons_1.py b/tests/opcodes/cases/test_cons_1.py
index 90d052deb..4bfd90b44 100644
--- a/tests/opcodes/cases/test_cons_1.py
+++ b/tests/opcodes/cases/test_cons_1.py
@@ -20,6 +20,6 @@ def test_opcode_cons_1(self):
         res = self.i.execute('RUN -5 { 10 }')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ -5 ; 10 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ -5 ; 10 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_cons_2.py b/tests/opcodes/cases/test_cons_2.py
index 98ea91a5a..344646d6a 100644
--- a/tests/opcodes/cases/test_cons_2.py
+++ b/tests/opcodes/cases/test_cons_2.py
@@ -20,6 +20,6 @@ def test_opcode_cons_2(self):
         res = self.i.execute('RUN 99 { -5 ; 10 }')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 99 ; -5 ; 10 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 99 ; -5 ; 10 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_160.py b/tests/opcodes/cases/test_contains_all_160.py
index f7fbba8d1..1b2f99bc7 100644
--- a/tests/opcodes/cases/test_contains_all_160.py
+++ b/tests/opcodes/cases/test_contains_all_160.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_160(self):
         res = self.i.execute('RUN (Pair {} {}) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_161.py b/tests/opcodes/cases/test_contains_all_161.py
index cab01d414..82e2728a3 100644
--- a/tests/opcodes/cases/test_contains_all_161.py
+++ b/tests/opcodes/cases/test_contains_all_161.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_161(self):
         res = self.i.execute('RUN (Pair { "a" } { "B" }) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_162.py b/tests/opcodes/cases/test_contains_all_162.py
index cd93396ce..46dca519c 100644
--- a/tests/opcodes/cases/test_contains_all_162.py
+++ b/tests/opcodes/cases/test_contains_all_162.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_162(self):
         res = self.i.execute('RUN (Pair { "A" } { "B" }) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_163.py b/tests/opcodes/cases/test_contains_all_163.py
index 82bb75bd8..4e0a4001b 100644
--- a/tests/opcodes/cases/test_contains_all_163.py
+++ b/tests/opcodes/cases/test_contains_all_163.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_163(self):
         res = self.i.execute('RUN (Pair { "B" } { "B" }) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_164.py b/tests/opcodes/cases/test_contains_all_164.py
index 96f5e2f19..afb71380a 100644
--- a/tests/opcodes/cases/test_contains_all_164.py
+++ b/tests/opcodes/cases/test_contains_all_164.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_164(self):
         res = self.i.execute('RUN (Pair { "B" ; "C" ; "asdf" } { "B" ; "B" ; "asdf" ; "C" }) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contains_all_165.py b/tests/opcodes/cases/test_contains_all_165.py
index 3cccc34c5..1cc95f2da 100644
--- a/tests/opcodes/cases/test_contains_all_165.py
+++ b/tests/opcodes/cases/test_contains_all_165.py
@@ -20,6 +20,6 @@ def test_opcode_contains_all_165(self):
         res = self.i.execute('RUN (Pair { "B" ; "B" ; "asdf" ; "C" } { "B" ; "C" ; "asdf" }) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_contract_239.py b/tests/opcodes/cases/test_contract_239.py
index ecba14694..12490e233 100644
--- a/tests/opcodes/cases/test_contract_239.py
+++ b/tests/opcodes/cases/test_contract_239.py
@@ -20,6 +20,6 @@ def test_opcode_contract_239(self):
         res = self.i.execute('RUN "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5" Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_create_contract_240.py b/tests/opcodes/cases/test_create_contract_240.py
index 70edd2b90..f25582a0e 100644
--- a/tests/opcodes/cases/test_create_contract_240.py
+++ b/tests/opcodes/cases/test_create_contract_240.py
@@ -20,6 +20,6 @@ def test_opcode_create_contract_240(self):
         res = self.i.execute('RUN Unit None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "KT1Mjjcb6tmSsLm7Cb3DSQszePjfchPM4Uxm")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "KT1Mjjcb6tmSsLm7Cb3DSQszePjfchPM4Uxm")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_diff_timestamps_218.py b/tests/opcodes/cases/test_diff_timestamps_218.py
index d68e422bc..53a7a6f52 100644
--- a/tests/opcodes/cases/test_diff_timestamps_218.py
+++ b/tests/opcodes/cases/test_diff_timestamps_218.py
@@ -20,6 +20,6 @@ def test_opcode_diff_timestamps_218(self):
         res = self.i.execute('RUN (Pair 0 0) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_diff_timestamps_219.py b/tests/opcodes/cases/test_diff_timestamps_219.py
index 72d3a628d..3d2824f28 100644
--- a/tests/opcodes/cases/test_diff_timestamps_219.py
+++ b/tests/opcodes/cases/test_diff_timestamps_219.py
@@ -20,6 +20,6 @@ def test_opcode_diff_timestamps_219(self):
         res = self.i.execute('RUN (Pair 0 1) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('-1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('-1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_diff_timestamps_220.py b/tests/opcodes/cases/test_diff_timestamps_220.py
index 129cb042c..81e378e77 100644
--- a/tests/opcodes/cases/test_diff_timestamps_220.py
+++ b/tests/opcodes/cases/test_diff_timestamps_220.py
@@ -20,6 +20,6 @@ def test_opcode_diff_timestamps_220(self):
         res = self.i.execute('RUN (Pair 1 0) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_diff_timestamps_221.py b/tests/opcodes/cases/test_diff_timestamps_221.py
index f8ee10cca..ec04089df 100644
--- a/tests/opcodes/cases/test_diff_timestamps_221.py
+++ b/tests/opcodes/cases/test_diff_timestamps_221.py
@@ -20,6 +20,6 @@ def test_opcode_diff_timestamps_221(self):
         res = self.i.execute('RUN (Pair "1970-01-01T00:03:20Z" "1970-01-01T00:00:00Z") 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('200')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('200')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dig_eq_251.py b/tests/opcodes/cases/test_dig_eq_251.py
index db16a0491..f0be48330 100644
--- a/tests/opcodes/cases/test_dig_eq_251.py
+++ b/tests/opcodes/cases/test_dig_eq_251.py
@@ -20,6 +20,6 @@ def test_opcode_dig_eq_251(self):
         res = self.i.execute('RUN (Pair 17 (Pair 16 (Pair 15 (Pair 14 (Pair 13 (Pair 12 (Pair 11 (Pair 10 (Pair 9 (Pair 8 (Pair 7 (Pair 6 (Pair 5 (Pair 4 (Pair 3 (Pair 2 1)))))))))))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dig_eq_252.py b/tests/opcodes/cases/test_dig_eq_252.py
index 3580392ee..39bd6be98 100644
--- a/tests/opcodes/cases/test_dig_eq_252.py
+++ b/tests/opcodes/cases/test_dig_eq_252.py
@@ -20,6 +20,6 @@ def test_opcode_dig_eq_252(self):
         res = self.i.execute('RUN (Pair 2 (Pair 3 (Pair 12 (Pair 16 (Pair 10 (Pair 14 (Pair 19 (Pair 9 (Pair 18 (Pair 6 (Pair 8 (Pair 11 (Pair 4 (Pair 13 (Pair 15 (Pair 5 1)))))))))))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dign_247.py b/tests/opcodes/cases/test_dign_247.py
index 3c804cb2c..cead10a13 100644
--- a/tests/opcodes/cases/test_dign_247.py
+++ b/tests/opcodes/cases/test_dign_247.py
@@ -20,6 +20,6 @@ def test_opcode_dign_247(self):
         res = self.i.execute('RUN (Pair (Pair (Pair (Pair 1 2) 3) 4) 5) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('5')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('5')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dip_193.py b/tests/opcodes/cases/test_dip_193.py
index d29fdd33d..33a111543 100644
--- a/tests/opcodes/cases/test_dip_193.py
+++ b/tests/opcodes/cases/test_dip_193.py
@@ -20,6 +20,6 @@ def test_opcode_dip_193(self):
         res = self.i.execute('RUN (Pair 15 9) (Pair 0 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 15 24)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 15 24)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dip_194.py b/tests/opcodes/cases/test_dip_194.py
index 61dfd5f43..6ce6f5dfa 100644
--- a/tests/opcodes/cases/test_dip_194.py
+++ b/tests/opcodes/cases/test_dip_194.py
@@ -20,6 +20,6 @@ def test_opcode_dip_194(self):
         res = self.i.execute('RUN (Pair 1 1) (Pair 0 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 1 2)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 1 2)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dipn_250.py b/tests/opcodes/cases/test_dipn_250.py
index 5655f678a..7f42c61fc 100644
--- a/tests/opcodes/cases/test_dipn_250.py
+++ b/tests/opcodes/cases/test_dipn_250.py
@@ -20,6 +20,6 @@ def test_opcode_dipn_250(self):
         res = self.i.execute('RUN (Pair (Pair (Pair (Pair 1 2) 3) 4) 5) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('6')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('6')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dropn_249.py b/tests/opcodes/cases/test_dropn_249.py
index c5068e064..5e917f446 100644
--- a/tests/opcodes/cases/test_dropn_249.py
+++ b/tests/opcodes/cases/test_dropn_249.py
@@ -20,6 +20,6 @@ def test_opcode_dropn_249(self):
         res = self.i.execute('RUN (Pair (Pair (Pair (Pair 1 2) 3) 4) 5) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('5')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('5')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_dugn_248.py b/tests/opcodes/cases/test_dugn_248.py
index 6cbd762c6..177954bb1 100644
--- a/tests/opcodes/cases/test_dugn_248.py
+++ b/tests/opcodes/cases/test_dugn_248.py
@@ -20,6 +20,6 @@ def test_opcode_dugn_248(self):
         res = self.i.execute('RUN (Pair (Pair (Pair (Pair 1 2) 3) 4) 5) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_226.py b/tests/opcodes/cases/test_ediv_226.py
index 2b95089e1..8da0cf1fc 100644
--- a/tests/opcodes/cases/test_ediv_226.py
+++ b/tests/opcodes/cases/test_ediv_226.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_226(self):
         res = self.i.execute('RUN (Pair 10 -3) (Pair None (Pair None (Pair None None)))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Some (Pair -3 1)) (Pair (Some (Pair 3 1)) (Pair (Some (Pair -3 1)) (Some (Pair 3 1)))))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Some (Pair -3 1)) (Pair (Some (Pair 3 1)) (Pair (Some (Pair -3 1)) (Some (Pair 3 1)))))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_227.py b/tests/opcodes/cases/test_ediv_227.py
index 5b236f7df..7b51a8428 100644
--- a/tests/opcodes/cases/test_ediv_227.py
+++ b/tests/opcodes/cases/test_ediv_227.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_227(self):
         res = self.i.execute('RUN (Pair 10 0) (Pair None (Pair None (Pair None None)))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair None (Pair None (Pair None None)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair None (Pair None (Pair None None)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_228.py b/tests/opcodes/cases/test_ediv_228.py
index 7612e2d04..527c528c1 100644
--- a/tests/opcodes/cases/test_ediv_228.py
+++ b/tests/opcodes/cases/test_ediv_228.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_228(self):
         res = self.i.execute('RUN (Pair -8 2) (Pair None (Pair None (Pair None None)))')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Some (Pair -4 0)) (Pair (Some (Pair -4 0)) (Pair (Some (Pair 4 0)) (Some (Pair 4 0)))))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Some (Pair -4 0)) (Pair (Some (Pair -4 0)) (Pair (Some (Pair 4 0)) (Some (Pair 4 0)))))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_229.py b/tests/opcodes/cases/test_ediv_mutez_229.py
index 140553638..4b2919001 100644
--- a/tests/opcodes/cases/test_ediv_mutez_229.py
+++ b/tests/opcodes/cases/test_ediv_mutez_229.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_229(self):
         res = self.i.execute('RUN (Pair 10 (Left 10)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Some (Pair 1 0)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Some (Pair 1 0)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_230.py b/tests/opcodes/cases/test_ediv_mutez_230.py
index 5f7091b0d..8584e5428 100644
--- a/tests/opcodes/cases/test_ediv_mutez_230.py
+++ b/tests/opcodes/cases/test_ediv_mutez_230.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_230(self):
         res = self.i.execute('RUN (Pair 10 (Left 3)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left (Some (Pair 3 1)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left (Some (Pair 3 1)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_231.py b/tests/opcodes/cases/test_ediv_mutez_231.py
index 132d3ab6a..c02754af7 100644
--- a/tests/opcodes/cases/test_ediv_mutez_231.py
+++ b/tests/opcodes/cases/test_ediv_mutez_231.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_231(self):
         res = self.i.execute('RUN (Pair 10 (Left 0)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left None)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left None)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_232.py b/tests/opcodes/cases/test_ediv_mutez_232.py
index 1696c3a00..52742b35c 100644
--- a/tests/opcodes/cases/test_ediv_mutez_232.py
+++ b/tests/opcodes/cases/test_ediv_mutez_232.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_232(self):
         res = self.i.execute('RUN (Pair 10 (Right 10)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right (Some (Pair 1 0)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right (Some (Pair 1 0)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_233.py b/tests/opcodes/cases/test_ediv_mutez_233.py
index 32fecbb0b..8e1a7262e 100644
--- a/tests/opcodes/cases/test_ediv_mutez_233.py
+++ b/tests/opcodes/cases/test_ediv_mutez_233.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_233(self):
         res = self.i.execute('RUN (Pair 10 (Right 3)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right (Some (Pair 3 1)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right (Some (Pair 3 1)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_234.py b/tests/opcodes/cases/test_ediv_mutez_234.py
index 882541761..95f538039 100644
--- a/tests/opcodes/cases/test_ediv_mutez_234.py
+++ b/tests/opcodes/cases/test_ediv_mutez_234.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_234(self):
         res = self.i.execute('RUN (Pair 10 (Right 0)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right None)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right None)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ediv_mutez_235.py b/tests/opcodes/cases/test_ediv_mutez_235.py
index c779eb0aa..4781f8474 100644
--- a/tests/opcodes/cases/test_ediv_mutez_235.py
+++ b/tests/opcodes/cases/test_ediv_mutez_235.py
@@ -20,6 +20,6 @@ def test_opcode_ediv_mutez_235(self):
         res = self.i.execute('RUN (Pair 5 (Right 10)) (Left None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right (Some (Pair 0 5)))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right (Some (Pair 0 5)))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_empty_map_169.py b/tests/opcodes/cases/test_empty_map_169.py
index fd02b6191..dd637a3cf 100644
--- a/tests/opcodes/cases/test_empty_map_169.py
+++ b/tests/opcodes/cases/test_empty_map_169.py
@@ -20,6 +20,6 @@ def test_opcode_empty_map_169(self):
         res = self.i.execute('RUN Unit {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt "hello" "world" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt "hello" "world" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_exec_concat_181.py b/tests/opcodes/cases/test_exec_concat_181.py
index e66a5c0d4..a98c751d0 100644
--- a/tests/opcodes/cases/test_exec_concat_181.py
+++ b/tests/opcodes/cases/test_exec_concat_181.py
@@ -20,6 +20,6 @@ def test_opcode_exec_concat_181(self):
         res = self.i.execute('RUN "" "?"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"_abc"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"_abc"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_exec_concat_182.py b/tests/opcodes/cases/test_exec_concat_182.py
index c27ea63a2..f451302c5 100644
--- a/tests/opcodes/cases/test_exec_concat_182.py
+++ b/tests/opcodes/cases/test_exec_concat_182.py
@@ -20,6 +20,6 @@ def test_opcode_exec_concat_182(self):
         res = self.i.execute('RUN "test" "?"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"test_abc"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"test_abc"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_first_195.py b/tests/opcodes/cases/test_first_195.py
index 584a5725b..e78af5cc5 100644
--- a/tests/opcodes/cases/test_first_195.py
+++ b/tests/opcodes/cases/test_first_195.py
@@ -20,6 +20,6 @@ def test_opcode_first_195(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 ; 4 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_first_196.py b/tests/opcodes/cases/test_first_196.py
index 8af6e1276..a37d838a5 100644
--- a/tests/opcodes/cases/test_first_196.py
+++ b/tests/opcodes/cases/test_first_196.py
@@ -20,6 +20,6 @@ def test_opcode_first_196(self):
         res = self.i.execute('RUN { 4 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('4')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('4')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_get_big_map_value_0.py b/tests/opcodes/cases/test_get_big_map_value_0.py
index 985e46906..4298cee42 100644
--- a/tests/opcodes/cases/test_get_big_map_value_0.py
+++ b/tests/opcodes/cases/test_get_big_map_value_0.py
@@ -20,9 +20,9 @@ def test_opcode_get_big_map_value_0(self):
         res = self.i.execute('RUN "hello" (Pair { Elt "hello" "hi" } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some "hi"))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some "hi"))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtsjEVVZk3Gm82U9wEs8kvwRiQwUT7zipJwvCeFMNsApe2tQ15s', 'key': {'string': 'hello'}, 'value': {'string': 'hi'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_get_big_map_value_1.py b/tests/opcodes/cases/test_get_big_map_value_1.py
index 77c17f0be..d700d87ad 100644
--- a/tests/opcodes/cases/test_get_big_map_value_1.py
+++ b/tests/opcodes/cases/test_get_big_map_value_1.py
@@ -20,9 +20,9 @@ def test_opcode_get_big_map_value_1(self):
         res = self.i.execute('RUN "" (Pair { Elt "hello" "hi" } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 None)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 None)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtsjEVVZk3Gm82U9wEs8kvwRiQwUT7zipJwvCeFMNsApe2tQ15s', 'key': {'string': 'hello'}, 'value': {'string': 'hi'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_get_big_map_value_2.py b/tests/opcodes/cases/test_get_big_map_value_2.py
index 88669b39d..b8817b109 100644
--- a/tests/opcodes/cases/test_get_big_map_value_2.py
+++ b/tests/opcodes/cases/test_get_big_map_value_2.py
@@ -20,9 +20,9 @@ def test_opcode_get_big_map_value_2(self):
         res = self.i.execute('RUN "1" (Pair { Elt "1" "one" ; Elt "2" "two" } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 (Some "one"))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 (Some "one"))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_get_map_value_170.py b/tests/opcodes/cases/test_get_map_value_170.py
index 3d2977634..d1a90da2a 100644
--- a/tests/opcodes/cases/test_get_map_value_170.py
+++ b/tests/opcodes/cases/test_get_map_value_170.py
@@ -20,6 +20,6 @@ def test_opcode_get_map_value_170(self):
         res = self.i.execute('RUN "hello" (Pair None { Elt "hello" "hi" })')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Some "hi") { Elt "hello" "hi" })')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Some "hi") { Elt "hello" "hi" })')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_get_map_value_171.py b/tests/opcodes/cases/test_get_map_value_171.py
index 784610820..c8feb7b1a 100644
--- a/tests/opcodes/cases/test_get_map_value_171.py
+++ b/tests/opcodes/cases/test_get_map_value_171.py
@@ -20,6 +20,6 @@ def test_opcode_get_map_value_171(self):
         res = self.i.execute('RUN "" (Pair None { Elt "hello" "hi" })')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair None { Elt "hello" "hi" })')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair None { Elt "hello" "hi" })')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_get_map_value_172.py b/tests/opcodes/cases/test_get_map_value_172.py
index b45679e49..45227676a 100644
--- a/tests/opcodes/cases/test_get_map_value_172.py
+++ b/tests/opcodes/cases/test_get_map_value_172.py
@@ -20,6 +20,6 @@ def test_opcode_get_map_value_172(self):
         res = self.i.execute('RUN "1" (Pair None { Elt "1" "one" ;     Elt "2" "two" })')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Some "one") { Elt "1" "one" ; Elt "2" "two" })')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Some "one") { Elt "1" "one" ; Elt "2" "two" })')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_hash_key_207.py b/tests/opcodes/cases/test_hash_key_207.py
index edc7ec5e9..03d65e203 100644
--- a/tests/opcodes/cases/test_hash_key_207.py
+++ b/tests/opcodes/cases/test_hash_key_207.py
@@ -20,6 +20,6 @@ def test_opcode_hash_key_207(self):
         res = self.i.execute('RUN "edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav" None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_hash_key_208.py b/tests/opcodes/cases/test_hash_key_208.py
index 8e94120c0..c2aa3017b 100644
--- a/tests/opcodes/cases/test_hash_key_208.py
+++ b/tests/opcodes/cases/test_hash_key_208.py
@@ -20,6 +20,6 @@ def test_opcode_hash_key_208(self):
         res = self.i.execute('RUN "edpkuJqtDcA2m2muMxViSM47MPsGQzmyjnNTawUPqR8vZTAMcx61ES" None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "tz1XPTDmvT3vVE5Uunngmixm7gj7zmdbPq6k")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "tz1XPTDmvT3vVE5Uunngmixm7gj7zmdbPq6k")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_hash_string_197.py b/tests/opcodes/cases/test_hash_string_197.py
index a8a88b7eb..fbf420c8d 100644
--- a/tests/opcodes/cases/test_hash_string_197.py
+++ b/tests/opcodes/cases/test_hash_string_197.py
@@ -20,6 +20,6 @@ def test_opcode_hash_string_197(self):
         res = self.i.execute('RUN "abcdefg" 0x00')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0x46fdbcb4ea4eadad5615cdaa17d67f783e01e21149ce2b27de497600b4cd8f4e')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0x46fdbcb4ea4eadad5615cdaa17d67f783e01e21149ce2b27de497600b4cd8f4e')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_hash_string_198.py b/tests/opcodes/cases/test_hash_string_198.py
index e8f21d044..8960e5c6d 100644
--- a/tests/opcodes/cases/test_hash_string_198.py
+++ b/tests/opcodes/cases/test_hash_string_198.py
@@ -20,6 +20,6 @@ def test_opcode_hash_string_198(self):
         res = self.i.execute('RUN "12345" 0x00')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0xb4c26c20de52a4eaf0d8a340db47ad8cb1e74049570859c9a9a3952b204c772f')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0xb4c26c20de52a4eaf0d8a340db47ad8cb1e74049570859c9a9a3952b204c772f')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_if_175.py b/tests/opcodes/cases/test_if_175.py
index 82324f606..1ace5fb8c 100644
--- a/tests/opcodes/cases/test_if_175.py
+++ b/tests/opcodes/cases/test_if_175.py
@@ -20,6 +20,6 @@ def test_opcode_if_175(self):
         res = self.i.execute('RUN True None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_if_176.py b/tests/opcodes/cases/test_if_176.py
index 9fa44273a..4d113069c 100644
--- a/tests/opcodes/cases/test_if_176.py
+++ b/tests/opcodes/cases/test_if_176.py
@@ -20,6 +20,6 @@ def test_opcode_if_176(self):
         res = self.i.execute('RUN False None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_if_some_199.py b/tests/opcodes/cases/test_if_some_199.py
index a9f170465..b2ed3f637 100644
--- a/tests/opcodes/cases/test_if_some_199.py
+++ b/tests/opcodes/cases/test_if_some_199.py
@@ -20,6 +20,6 @@ def test_opcode_if_some_199(self):
         res = self.i.execute('RUN (Some "hello") "?"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"hello"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"hello"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_if_some_200.py b/tests/opcodes/cases/test_if_some_200.py
index 4ad826a3d..9cf349439 100644
--- a/tests/opcodes/cases/test_if_some_200.py
+++ b/tests/opcodes/cases/test_if_some_200.py
@@ -20,6 +20,6 @@ def test_opcode_if_some_200(self):
         res = self.i.execute('RUN None "?"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('""')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('""')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_int_190.py b/tests/opcodes/cases/test_int_190.py
index f1fb6d5da..072203faf 100644
--- a/tests/opcodes/cases/test_int_190.py
+++ b/tests/opcodes/cases/test_int_190.py
@@ -20,6 +20,6 @@ def test_opcode_int_190(self):
         res = self.i.execute('RUN 0 None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_int_191.py b/tests/opcodes/cases/test_int_191.py
index 4150c5d86..218455d5e 100644
--- a/tests/opcodes/cases/test_int_191.py
+++ b/tests/opcodes/cases/test_int_191.py
@@ -20,6 +20,6 @@ def test_opcode_int_191(self):
         res = self.i.execute('RUN 1 None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_int_192.py b/tests/opcodes/cases/test_int_192.py
index cf14d9dba..b9960e337 100644
--- a/tests/opcodes/cases/test_int_192.py
+++ b/tests/opcodes/cases/test_int_192.py
@@ -20,6 +20,6 @@ def test_opcode_int_192(self):
         res = self.i.execute('RUN 9999 None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 9999)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 9999)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_left_right_177.py b/tests/opcodes/cases/test_left_right_177.py
index eafdfb611..e2e1858bb 100644
--- a/tests/opcodes/cases/test_left_right_177.py
+++ b/tests/opcodes/cases/test_left_right_177.py
@@ -20,6 +20,6 @@ def test_opcode_left_right_177(self):
         res = self.i.execute('RUN (Left True) (Left "X")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Right True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Right True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_left_right_178.py b/tests/opcodes/cases/test_left_right_178.py
index 134db5dcd..ac79cbda0 100644
--- a/tests/opcodes/cases/test_left_right_178.py
+++ b/tests/opcodes/cases/test_left_right_178.py
@@ -20,6 +20,6 @@ def test_opcode_left_right_178(self):
         res = self.i.execute('RUN (Right "a") (Left "X")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Left "a")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Left "a")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_134.py b/tests/opcodes/cases/test_list_concat_134.py
index 0cccaf7bd..19fd3a45a 100644
--- a/tests/opcodes/cases/test_list_concat_134.py
+++ b/tests/opcodes/cases/test_list_concat_134.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_134(self):
         res = self.i.execute('RUN { "d" ; "e" ; "f" } "abc"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"abcdef"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"abcdef"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_135.py b/tests/opcodes/cases/test_list_concat_135.py
index 7d8ba29d9..48c98d546 100644
--- a/tests/opcodes/cases/test_list_concat_135.py
+++ b/tests/opcodes/cases/test_list_concat_135.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_135(self):
         res = self.i.execute('RUN {} "abc"')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"abc"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"abc"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_bytes_136.py b/tests/opcodes/cases/test_list_concat_bytes_136.py
index 9f2cd84e6..fd24a3c9d 100644
--- a/tests/opcodes/cases/test_list_concat_bytes_136.py
+++ b/tests/opcodes/cases/test_list_concat_bytes_136.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_bytes_136(self):
         res = self.i.execute('RUN { 0xcd ; 0xef ; 0x00 } 0x00ab')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0x00abcdef00')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0x00abcdef00')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_bytes_137.py b/tests/opcodes/cases/test_list_concat_bytes_137.py
index b9a3aaf03..b98cc38ea 100644
--- a/tests/opcodes/cases/test_list_concat_bytes_137.py
+++ b/tests/opcodes/cases/test_list_concat_bytes_137.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_bytes_137(self):
         res = self.i.execute('RUN { 0x00 ; 0x11 ; 0x00 } 0x')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0x001100')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0x001100')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_bytes_138.py b/tests/opcodes/cases/test_list_concat_bytes_138.py
index 143fd5938..257f2e4c6 100644
--- a/tests/opcodes/cases/test_list_concat_bytes_138.py
+++ b/tests/opcodes/cases/test_list_concat_bytes_138.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_bytes_138(self):
         res = self.i.execute('RUN {} 0xabcd')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0xabcd')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0xabcd')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_concat_bytes_139.py b/tests/opcodes/cases/test_list_concat_bytes_139.py
index 21a548c94..f8e56668b 100644
--- a/tests/opcodes/cases/test_list_concat_bytes_139.py
+++ b/tests/opcodes/cases/test_list_concat_bytes_139.py
@@ -20,6 +20,6 @@ def test_opcode_list_concat_bytes_139(self):
         res = self.i.execute('RUN {} 0x')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0x')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0x')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_89.py b/tests/opcodes/cases/test_list_id_89.py
index ab7b7c223..dd03e8563 100644
--- a/tests/opcodes/cases/test_list_id_89.py
+++ b/tests/opcodes/cases/test_list_id_89.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_89(self):
         res = self.i.execute('RUN { "1" ; "2" ; "3" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "1" ; "2" ; "3" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "1" ; "2" ; "3" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_90.py b/tests/opcodes/cases/test_list_id_90.py
index 91562a3b7..081703528 100644
--- a/tests/opcodes/cases/test_list_id_90.py
+++ b/tests/opcodes/cases/test_list_id_90.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_90(self):
         res = self.i.execute('RUN {} {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_91.py b/tests/opcodes/cases/test_list_id_91.py
index 26f7b5b15..1e2b4e70f 100644
--- a/tests/opcodes/cases/test_list_id_91.py
+++ b/tests/opcodes/cases/test_list_id_91.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_91(self):
         res = self.i.execute('RUN { "a" ; "b" ; "c" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_map_92.py b/tests/opcodes/cases/test_list_id_map_92.py
index e69899d91..c461ed11c 100644
--- a/tests/opcodes/cases/test_list_id_map_92.py
+++ b/tests/opcodes/cases/test_list_id_map_92.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_map_92(self):
         res = self.i.execute('RUN { "1" ; "2" ; "3" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "1" ; "2" ; "3" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "1" ; "2" ; "3" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_map_93.py b/tests/opcodes/cases/test_list_id_map_93.py
index 93fd22c66..335c0c559 100644
--- a/tests/opcodes/cases/test_list_id_map_93.py
+++ b/tests/opcodes/cases/test_list_id_map_93.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_map_93(self):
         res = self.i.execute('RUN {} {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_id_map_94.py b/tests/opcodes/cases/test_list_id_map_94.py
index b926c5b58..8d1d3d7ad 100644
--- a/tests/opcodes/cases/test_list_id_map_94.py
+++ b/tests/opcodes/cases/test_list_id_map_94.py
@@ -20,6 +20,6 @@ def test_opcode_list_id_map_94(self):
         res = self.i.execute('RUN { "a" ; "b" ; "c" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_iter_140.py b/tests/opcodes/cases/test_list_iter_140.py
index 54db12391..3b43be8b1 100644
--- a/tests/opcodes/cases/test_list_iter_140.py
+++ b/tests/opcodes/cases/test_list_iter_140.py
@@ -20,6 +20,6 @@ def test_opcode_list_iter_140(self):
         res = self.i.execute('RUN { 10 ; 2 ; 1 } 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('20')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('20')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_iter_141.py b/tests/opcodes/cases/test_list_iter_141.py
index 217e41a27..0bf86d15d 100644
--- a/tests/opcodes/cases/test_list_iter_141.py
+++ b/tests/opcodes/cases/test_list_iter_141.py
@@ -20,6 +20,6 @@ def test_opcode_list_iter_141(self):
         res = self.i.execute('RUN { 3 ; 6 ; 9 } 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('162')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('162')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_map_block_5.py b/tests/opcodes/cases/test_list_map_block_5.py
index 78fb64b1d..834e37eb2 100644
--- a/tests/opcodes/cases/test_list_map_block_5.py
+++ b/tests/opcodes/cases/test_list_map_block_5.py
@@ -20,6 +20,6 @@ def test_opcode_list_map_block_5(self):
         res = self.i.execute('RUN {} {0}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_map_block_6.py b/tests/opcodes/cases/test_list_map_block_6.py
index bc60c1b79..93df3073e 100644
--- a/tests/opcodes/cases/test_list_map_block_6.py
+++ b/tests/opcodes/cases/test_list_map_block_6.py
@@ -20,6 +20,6 @@ def test_opcode_list_map_block_6(self):
         res = self.i.execute('RUN { 1 ; 1 ; 1 ; 1 } {0}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 1 ; 2 ; 3 ; 4 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 1 ; 2 ; 3 ; 4 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_map_block_7.py b/tests/opcodes/cases/test_list_map_block_7.py
index 9d564d952..cff602323 100644
--- a/tests/opcodes/cases/test_list_map_block_7.py
+++ b/tests/opcodes/cases/test_list_map_block_7.py
@@ -20,6 +20,6 @@ def test_opcode_list_map_block_7(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 ; 0 } {0}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 1 ; 3 ; 5 ; 3 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 1 ; 3 ; 5 ; 3 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_size_142.py b/tests/opcodes/cases/test_list_size_142.py
index 48b308160..602d6819e 100644
--- a/tests/opcodes/cases/test_list_size_142.py
+++ b/tests/opcodes/cases/test_list_size_142.py
@@ -20,6 +20,6 @@ def test_opcode_list_size_142(self):
         res = self.i.execute('RUN {} 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_size_143.py b/tests/opcodes/cases/test_list_size_143.py
index b1d7482c3..72d10243f 100644
--- a/tests/opcodes/cases/test_list_size_143.py
+++ b/tests/opcodes/cases/test_list_size_143.py
@@ -20,6 +20,6 @@ def test_opcode_list_size_143(self):
         res = self.i.execute('RUN { 1 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_size_144.py b/tests/opcodes/cases/test_list_size_144.py
index fc7811d98..00668f00c 100644
--- a/tests/opcodes/cases/test_list_size_144.py
+++ b/tests/opcodes/cases/test_list_size_144.py
@@ -20,6 +20,6 @@ def test_opcode_list_size_144(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('3')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('3')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_list_size_145.py b/tests/opcodes/cases/test_list_size_145.py
index 703bef2eb..a39df689f 100644
--- a/tests/opcodes/cases/test_list_size_145.py
+++ b/tests/opcodes/cases/test_list_size_145.py
@@ -20,6 +20,6 @@ def test_opcode_list_size_145(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 ; 4 ; 5 ; 6 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('6')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('6')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_loop_left_10.py b/tests/opcodes/cases/test_loop_left_10.py
index 8a82f4ff5..3c56bdcc7 100644
--- a/tests/opcodes/cases/test_loop_left_10.py
+++ b/tests/opcodes/cases/test_loop_left_10.py
@@ -20,6 +20,6 @@ def test_opcode_loop_left_10(self):
         res = self.i.execute('RUN {} {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_loop_left_11.py b/tests/opcodes/cases/test_loop_left_11.py
index 2aee8e6e4..65f0b70cc 100644
--- a/tests/opcodes/cases/test_loop_left_11.py
+++ b/tests/opcodes/cases/test_loop_left_11.py
@@ -20,6 +20,6 @@ def test_opcode_loop_left_11(self):
         res = self.i.execute('RUN { "c" ; "b" ; "a" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_macro_compare_269.py b/tests/opcodes/cases/test_macro_compare_269.py
index 94999e5b8..9a608c5bc 100644
--- a/tests/opcodes/cases/test_macro_compare_269.py
+++ b/tests/opcodes/cases/test_macro_compare_269.py
@@ -20,6 +20,6 @@ def test_opcode_macro_compare_269(self):
         res = self.i.execute('RUN (Pair 1000000 2000000) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ False ; False ; True ; False ; True }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_macro_compare_270.py b/tests/opcodes/cases/test_macro_compare_270.py
index 06fae1c85..6e6178fd4 100644
--- a/tests/opcodes/cases/test_macro_compare_270.py
+++ b/tests/opcodes/cases/test_macro_compare_270.py
@@ -20,6 +20,6 @@ def test_opcode_macro_compare_270(self):
         res = self.i.execute('RUN (Pair 2000000 1000000) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ False ; True ; False ; True ; False }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ False ; True ; False ; True ; False }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_macro_compare_271.py b/tests/opcodes/cases/test_macro_compare_271.py
index 8c3b57a70..4e856b7db 100644
--- a/tests/opcodes/cases/test_macro_compare_271.py
+++ b/tests/opcodes/cases/test_macro_compare_271.py
@@ -20,6 +20,6 @@ def test_opcode_macro_compare_271(self):
         res = self.i.execute('RUN (Pair 2370000 2370000) {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ True ; False ; False ; True ; True }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ True ; False ; False ; True ; True }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_caddaadr_291.py b/tests/opcodes/cases/test_map_caddaadr_291.py
index e05e6bb05..8a1caaa89 100644
--- a/tests/opcodes/cases/test_map_caddaadr_291.py
+++ b/tests/opcodes/cases/test_map_caddaadr_291.py
@@ -20,6 +20,6 @@ def test_opcode_map_caddaadr_291(self):
         res = self.i.execute('RUN Unit (Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 0) 4) 5))) 6)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 1000000) 4) 5))) 6)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 1000000) 4) 5))) 6)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_id_95.py b/tests/opcodes/cases/test_map_id_95.py
index ec73303f4..f47521dc5 100644
--- a/tests/opcodes/cases/test_map_id_95.py
+++ b/tests/opcodes/cases/test_map_id_95.py
@@ -20,6 +20,6 @@ def test_opcode_map_id_95(self):
         res = self.i.execute('RUN { Elt 0 1 } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt 0 1 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt 0 1 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_id_96.py b/tests/opcodes/cases/test_map_id_96.py
index a8591fa60..cc6424d69 100644
--- a/tests/opcodes/cases/test_map_id_96.py
+++ b/tests/opcodes/cases/test_map_id_96.py
@@ -20,6 +20,6 @@ def test_opcode_map_id_96(self):
         res = self.i.execute('RUN { Elt 0 0 } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt 0 0 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt 0 0 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_id_97.py b/tests/opcodes/cases/test_map_id_97.py
index 1963d2f09..7c78e86b8 100644
--- a/tests/opcodes/cases/test_map_id_97.py
+++ b/tests/opcodes/cases/test_map_id_97.py
@@ -20,6 +20,6 @@ def test_opcode_map_id_97(self):
         res = self.i.execute('RUN { Elt 0 0 ; Elt 3 4 } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt 0 0 ; Elt 3 4 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt 0 0 ; Elt 3 4 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_iter_173.py b/tests/opcodes/cases/test_map_iter_173.py
index 4bdf51bd3..e2c0f5f02 100644
--- a/tests/opcodes/cases/test_map_iter_173.py
+++ b/tests/opcodes/cases/test_map_iter_173.py
@@ -20,6 +20,6 @@ def test_opcode_map_iter_173(self):
         res = self.i.execute('RUN { Elt 0 100 ; Elt 2 100 } (Pair 0 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 2 200)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 2 200)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_iter_174.py b/tests/opcodes/cases/test_map_iter_174.py
index 16a83e8ba..42be387e3 100644
--- a/tests/opcodes/cases/test_map_iter_174.py
+++ b/tests/opcodes/cases/test_map_iter_174.py
@@ -20,6 +20,6 @@ def test_opcode_map_iter_174(self):
         res = self.i.execute('RUN { Elt 1 1 ; Elt 2 100 } (Pair 0 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 3 101)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 3 101)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_map_110.py b/tests/opcodes/cases/test_map_map_110.py
index 88a6e3dde..883fc5e7e 100644
--- a/tests/opcodes/cases/test_map_map_110.py
+++ b/tests/opcodes/cases/test_map_map_110.py
@@ -20,6 +20,6 @@ def test_opcode_map_map_110(self):
         res = self.i.execute('RUN 10 {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_map_111.py b/tests/opcodes/cases/test_map_map_111.py
index 4e6f83c0d..78c5a39e1 100644
--- a/tests/opcodes/cases/test_map_map_111.py
+++ b/tests/opcodes/cases/test_map_map_111.py
@@ -20,6 +20,6 @@ def test_opcode_map_map_111(self):
         res = self.i.execute('RUN 10 { Elt "foo" 1 }')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt "foo" 11 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt "foo" 11 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_map_112.py b/tests/opcodes/cases/test_map_map_112.py
index 31a3b2bd9..79d903a99 100644
--- a/tests/opcodes/cases/test_map_map_112.py
+++ b/tests/opcodes/cases/test_map_map_112.py
@@ -20,6 +20,6 @@ def test_opcode_map_map_112(self):
         res = self.i.execute('RUN 15 { Elt "bar" 5 ; Elt "foo" 1 }')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ Elt "bar" 20 ; Elt "foo" 16 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ Elt "bar" 20 ; Elt "foo" 16 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_100.py b/tests/opcodes/cases/test_map_mem_nat_100.py
index 4a5411874..68ed860f3 100644
--- a/tests/opcodes/cases/test_map_mem_nat_100.py
+++ b/tests/opcodes/cases/test_map_mem_nat_100.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_100(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 0 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt 1 0 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt 1 0 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_101.py b/tests/opcodes/cases/test_map_mem_nat_101.py
index b4048bcbd..7ba88f9dc 100644
--- a/tests/opcodes/cases/test_map_mem_nat_101.py
+++ b/tests/opcodes/cases/test_map_mem_nat_101.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_101(self):
         res = self.i.execute('RUN 1 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_102.py b/tests/opcodes/cases/test_map_mem_nat_102.py
index 4e3380d08..4a9da3423 100644
--- a/tests/opcodes/cases/test_map_mem_nat_102.py
+++ b/tests/opcodes/cases/test_map_mem_nat_102.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_102(self):
         res = self.i.execute('RUN 2 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_103.py b/tests/opcodes/cases/test_map_mem_nat_103.py
index abe00724e..7829c4d60 100644
--- a/tests/opcodes/cases/test_map_mem_nat_103.py
+++ b/tests/opcodes/cases/test_map_mem_nat_103.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_103(self):
         res = self.i.execute('RUN 3 (Pair { Elt 1 4 ; Elt 2 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt 1 4 ; Elt 2 11 } (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_98.py b/tests/opcodes/cases/test_map_mem_nat_98.py
index 8939622a7..1887afdbf 100644
--- a/tests/opcodes/cases/test_map_mem_nat_98.py
+++ b/tests/opcodes/cases/test_map_mem_nat_98.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_98(self):
         res = self.i.execute('RUN 1 (Pair { Elt 0 1 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt 0 1 } (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt 0 1 } (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_nat_99.py b/tests/opcodes/cases/test_map_mem_nat_99.py
index 9e1125158..ac788aad0 100644
--- a/tests/opcodes/cases/test_map_mem_nat_99.py
+++ b/tests/opcodes/cases/test_map_mem_nat_99.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_nat_99(self):
         res = self.i.execute('RUN 1 (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair {} (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair {} (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_104.py b/tests/opcodes/cases/test_map_mem_string_104.py
index 0283187b6..c70f951d0 100644
--- a/tests/opcodes/cases/test_map_mem_string_104.py
+++ b/tests/opcodes/cases/test_map_mem_string_104.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_104(self):
         res = self.i.execute('RUN "bar" (Pair { Elt "foo" 1 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt "foo" 1 } (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt "foo" 1 } (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_105.py b/tests/opcodes/cases/test_map_mem_string_105.py
index ee2fb2ad0..bc4f99e00 100644
--- a/tests/opcodes/cases/test_map_mem_string_105.py
+++ b/tests/opcodes/cases/test_map_mem_string_105.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_105(self):
         res = self.i.execute('RUN "bar" (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair {} (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair {} (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_106.py b/tests/opcodes/cases/test_map_mem_string_106.py
index faeeb45fc..5bb623021 100644
--- a/tests/opcodes/cases/test_map_mem_string_106.py
+++ b/tests/opcodes/cases/test_map_mem_string_106.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_106(self):
         res = self.i.execute('RUN "foo" (Pair { Elt "foo" 0 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt "foo" 0 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt "foo" 0 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_107.py b/tests/opcodes/cases/test_map_mem_string_107.py
index d81d11a7d..58b4db6eb 100644
--- a/tests/opcodes/cases/test_map_mem_string_107.py
+++ b/tests/opcodes/cases/test_map_mem_string_107.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_107(self):
         res = self.i.execute('RUN "foo" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_108.py b/tests/opcodes/cases/test_map_mem_string_108.py
index 6da87867a..264e4a836 100644
--- a/tests/opcodes/cases/test_map_mem_string_108.py
+++ b/tests/opcodes/cases/test_map_mem_string_108.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_108(self):
         res = self.i.execute('RUN "bar" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_mem_string_109.py b/tests/opcodes/cases/test_map_mem_string_109.py
index 30b3ac769..1f56f9769 100644
--- a/tests/opcodes/cases/test_map_mem_string_109.py
+++ b/tests/opcodes/cases/test_map_mem_string_109.py
@@ -20,6 +20,6 @@ def test_opcode_map_mem_string_109(self):
         res = self.i.execute('RUN "baz" (Pair { Elt "bar" 4 ; Elt "foo" 11 } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { Elt "bar" 4 ; Elt "foo" 11 } (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_size_156.py b/tests/opcodes/cases/test_map_size_156.py
index 68dd0ca7f..679e08891 100644
--- a/tests/opcodes/cases/test_map_size_156.py
+++ b/tests/opcodes/cases/test_map_size_156.py
@@ -20,6 +20,6 @@ def test_opcode_map_size_156(self):
         res = self.i.execute('RUN {} 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_size_157.py b/tests/opcodes/cases/test_map_size_157.py
index 521616810..4966d7ba4 100644
--- a/tests/opcodes/cases/test_map_size_157.py
+++ b/tests/opcodes/cases/test_map_size_157.py
@@ -20,6 +20,6 @@ def test_opcode_map_size_157(self):
         res = self.i.execute('RUN { Elt "a" 1 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_size_158.py b/tests/opcodes/cases/test_map_size_158.py
index e4b57d372..b7b1589dd 100644
--- a/tests/opcodes/cases/test_map_size_158.py
+++ b/tests/opcodes/cases/test_map_size_158.py
@@ -20,6 +20,6 @@ def test_opcode_map_size_158(self):
         res = self.i.execute('RUN { Elt "a" 1 ; Elt "b" 2 ; Elt "c" 3 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('3')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('3')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_map_size_159.py b/tests/opcodes/cases/test_map_size_159.py
index a04efaf36..786aff0fe 100644
--- a/tests/opcodes/cases/test_map_size_159.py
+++ b/tests/opcodes/cases/test_map_size_159.py
@@ -20,6 +20,6 @@ def test_opcode_map_size_159(self):
         res = self.i.execute('RUN { Elt "a" 1 ; Elt "b" 2 ; Elt "c" 3 ;     Elt "d" 4 ; Elt "e" 5 ; Elt "f" 6 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('6')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('6')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_263.py b/tests/opcodes/cases/test_max_in_list_263.py
index e2bbb2806..bc7cb4f4a 100644
--- a/tests/opcodes/cases/test_max_in_list_263.py
+++ b/tests/opcodes/cases/test_max_in_list_263.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_263(self):
         res = self.i.execute('RUN {} None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_264.py b/tests/opcodes/cases/test_max_in_list_264.py
index 54bcc6036..242646a79 100644
--- a/tests/opcodes/cases/test_max_in_list_264.py
+++ b/tests/opcodes/cases/test_max_in_list_264.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_264(self):
         res = self.i.execute('RUN { 1 } None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_265.py b/tests/opcodes/cases/test_max_in_list_265.py
index 7e33e9455..bf934cb3c 100644
--- a/tests/opcodes/cases/test_max_in_list_265.py
+++ b/tests/opcodes/cases/test_max_in_list_265.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_265(self):
         res = self.i.execute('RUN { -1 } None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_266.py b/tests/opcodes/cases/test_max_in_list_266.py
index 8605469a5..35d5d1e58 100644
--- a/tests/opcodes/cases/test_max_in_list_266.py
+++ b/tests/opcodes/cases/test_max_in_list_266.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_266(self):
         res = self.i.execute('RUN { 10 ; -1 ; -20 ; 100 ; 0 } None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 100)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 100)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_267.py b/tests/opcodes/cases/test_max_in_list_267.py
index 650f89949..c8680394e 100644
--- a/tests/opcodes/cases/test_max_in_list_267.py
+++ b/tests/opcodes/cases/test_max_in_list_267.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_267(self):
         res = self.i.execute('RUN { 10 ; -1 ; -20 ; 100 ; 0 } None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 100)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 100)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_max_in_list_268.py b/tests/opcodes/cases/test_max_in_list_268.py
index 23996bb8f..2a7808d66 100644
--- a/tests/opcodes/cases/test_max_in_list_268.py
+++ b/tests/opcodes/cases/test_max_in_list_268.py
@@ -20,6 +20,6 @@ def test_opcode_max_in_list_268(self):
         res = self.i.execute('RUN { -10 ; -1 ; -20 ; -100 } None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_mul_241.py b/tests/opcodes/cases/test_mul_241.py
index 32acd0721..cc4b2bb18 100644
--- a/tests/opcodes/cases/test_mul_241.py
+++ b/tests/opcodes/cases/test_mul_241.py
@@ -20,6 +20,6 @@ def test_opcode_mul_241(self):
         res = self.i.execute('RUN Unit Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_neg_242.py b/tests/opcodes/cases/test_neg_242.py
index 2867cc7ef..cae4e623b 100644
--- a/tests/opcodes/cases/test_neg_242.py
+++ b/tests/opcodes/cases/test_neg_242.py
@@ -20,6 +20,6 @@ def test_opcode_neg_242(self):
         res = self.i.execute('RUN (Left 2) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('-2')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('-2')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_neg_243.py b/tests/opcodes/cases/test_neg_243.py
index 4a5345733..2999d8566 100644
--- a/tests/opcodes/cases/test_neg_243.py
+++ b/tests/opcodes/cases/test_neg_243.py
@@ -20,6 +20,6 @@ def test_opcode_neg_243(self):
         res = self.i.execute('RUN (Right 2) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('-2')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('-2')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_neg_244.py b/tests/opcodes/cases/test_neg_244.py
index 1bab97777..a5fd529e6 100644
--- a/tests/opcodes/cases/test_neg_244.py
+++ b/tests/opcodes/cases/test_neg_244.py
@@ -20,6 +20,6 @@ def test_opcode_neg_244(self):
         res = self.i.execute('RUN (Left 0) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_neg_245.py b/tests/opcodes/cases/test_neg_245.py
index 48816fd81..e27623b60 100644
--- a/tests/opcodes/cases/test_neg_245.py
+++ b/tests/opcodes/cases/test_neg_245.py
@@ -20,6 +20,6 @@ def test_opcode_neg_245(self):
         res = self.i.execute('RUN (Right 0) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_neg_246.py b/tests/opcodes/cases/test_neg_246.py
index 504a54c84..f6b1439b7 100644
--- a/tests/opcodes/cases/test_neg_246.py
+++ b/tests/opcodes/cases/test_neg_246.py
@@ -20,6 +20,6 @@ def test_opcode_neg_246(self):
         res = self.i.execute('RUN (Left -2) 0')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('2')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('2')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_none_3.py b/tests/opcodes/cases/test_none_3.py
index 1c38f4a7f..7371b4444 100644
--- a/tests/opcodes/cases/test_none_3.py
+++ b/tests/opcodes/cases/test_none_3.py
@@ -20,6 +20,6 @@ def test_opcode_none_3(self):
         res = self.i.execute('RUN Unit (Some 10)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_34.py b/tests/opcodes/cases/test_not_34.py
index 362d2a12e..ba5f65d65 100644
--- a/tests/opcodes/cases/test_not_34.py
+++ b/tests/opcodes/cases/test_not_34.py
@@ -20,6 +20,6 @@ def test_opcode_not_34(self):
         res = self.i.execute('RUN True None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_35.py b/tests/opcodes/cases/test_not_35.py
index 5426e3d11..e4469d592 100644
--- a/tests/opcodes/cases/test_not_35.py
+++ b/tests/opcodes/cases/test_not_35.py
@@ -20,6 +20,6 @@ def test_opcode_not_35(self):
         res = self.i.execute('RUN False None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_55.py b/tests/opcodes/cases/test_not_binary_55.py
index 9a16a7572..6b330660d 100644
--- a/tests/opcodes/cases/test_not_binary_55.py
+++ b/tests/opcodes/cases/test_not_binary_55.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_55(self):
         res = self.i.execute('RUN (Left 0) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_56.py b/tests/opcodes/cases/test_not_binary_56.py
index aae85629b..ef1fe8e84 100644
--- a/tests/opcodes/cases/test_not_binary_56.py
+++ b/tests/opcodes/cases/test_not_binary_56.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_56(self):
         res = self.i.execute('RUN (Left 8) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -9)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -9)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_57.py b/tests/opcodes/cases/test_not_binary_57.py
index 044cfe057..4bb1fab89 100644
--- a/tests/opcodes/cases/test_not_binary_57.py
+++ b/tests/opcodes/cases/test_not_binary_57.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_57(self):
         res = self.i.execute('RUN (Left 7) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -8)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -8)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_58.py b/tests/opcodes/cases/test_not_binary_58.py
index b3e7553fe..06722aab3 100644
--- a/tests/opcodes/cases/test_not_binary_58.py
+++ b/tests/opcodes/cases/test_not_binary_58.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_58(self):
         res = self.i.execute('RUN (Left -9) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 8)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 8)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_59.py b/tests/opcodes/cases/test_not_binary_59.py
index 361e6f63b..eaff939e2 100644
--- a/tests/opcodes/cases/test_not_binary_59.py
+++ b/tests/opcodes/cases/test_not_binary_59.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_59(self):
         res = self.i.execute('RUN (Left -8) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 7)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 7)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_60.py b/tests/opcodes/cases/test_not_binary_60.py
index ccdfc6a0b..75f946621 100644
--- a/tests/opcodes/cases/test_not_binary_60.py
+++ b/tests/opcodes/cases/test_not_binary_60.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_60(self):
         res = self.i.execute('RUN (Right 0) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_61.py b/tests/opcodes/cases/test_not_binary_61.py
index 8ef95baaf..0313847d5 100644
--- a/tests/opcodes/cases/test_not_binary_61.py
+++ b/tests/opcodes/cases/test_not_binary_61.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_61(self):
         res = self.i.execute('RUN (Right 8) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -9)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -9)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_not_binary_62.py b/tests/opcodes/cases/test_not_binary_62.py
index c352270be..094e80e87 100644
--- a/tests/opcodes/cases/test_not_binary_62.py
+++ b/tests/opcodes/cases/test_not_binary_62.py
@@ -20,6 +20,6 @@ def test_opcode_not_binary_62(self):
         res = self.i.execute('RUN (Right 7) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some -8)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some -8)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_40.py b/tests/opcodes/cases/test_or_40.py
index 3e050edc9..9b39e2afc 100644
--- a/tests/opcodes/cases/test_or_40.py
+++ b/tests/opcodes/cases/test_or_40.py
@@ -20,6 +20,6 @@ def test_opcode_or_40(self):
         res = self.i.execute('RUN (Pair False False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some False)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some False)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_41.py b/tests/opcodes/cases/test_or_41.py
index 2f68b5240..59301868b 100644
--- a/tests/opcodes/cases/test_or_41.py
+++ b/tests/opcodes/cases/test_or_41.py
@@ -20,6 +20,6 @@ def test_opcode_or_41(self):
         res = self.i.execute('RUN (Pair False True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_42.py b/tests/opcodes/cases/test_or_42.py
index 3973c47db..318880616 100644
--- a/tests/opcodes/cases/test_or_42.py
+++ b/tests/opcodes/cases/test_or_42.py
@@ -20,6 +20,6 @@ def test_opcode_or_42(self):
         res = self.i.execute('RUN (Pair True False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_43.py b/tests/opcodes/cases/test_or_43.py
index d2947957a..d1e2ec9e5 100644
--- a/tests/opcodes/cases/test_or_43.py
+++ b/tests/opcodes/cases/test_or_43.py
@@ -20,6 +20,6 @@ def test_opcode_or_43(self):
         res = self.i.execute('RUN (Pair True True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some True)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some True)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_49.py b/tests/opcodes/cases/test_or_binary_49.py
index 688464e87..88ca4705d 100644
--- a/tests/opcodes/cases/test_or_binary_49.py
+++ b/tests/opcodes/cases/test_or_binary_49.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_49(self):
         res = self.i.execute('RUN (Pair 4 8) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 12)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 12)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_50.py b/tests/opcodes/cases/test_or_binary_50.py
index 0b6e1cb3d..4dc47a58d 100644
--- a/tests/opcodes/cases/test_or_binary_50.py
+++ b/tests/opcodes/cases/test_or_binary_50.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_50(self):
         res = self.i.execute('RUN (Pair 0 8) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 8)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 8)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_51.py b/tests/opcodes/cases/test_or_binary_51.py
index 953cf47ad..12167442b 100644
--- a/tests/opcodes/cases/test_or_binary_51.py
+++ b/tests/opcodes/cases/test_or_binary_51.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_51(self):
         res = self.i.execute('RUN (Pair 8 0) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 8)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 8)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_52.py b/tests/opcodes/cases/test_or_binary_52.py
index fcc008fc2..8c86b2233 100644
--- a/tests/opcodes/cases/test_or_binary_52.py
+++ b/tests/opcodes/cases/test_or_binary_52.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_52(self):
         res = self.i.execute('RUN (Pair 15 4) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 15)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 15)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_53.py b/tests/opcodes/cases/test_or_binary_53.py
index 8fa7aaefc..09098c43b 100644
--- a/tests/opcodes/cases/test_or_binary_53.py
+++ b/tests/opcodes/cases/test_or_binary_53.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_53(self):
         res = self.i.execute('RUN (Pair 14 1) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 15)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 15)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_or_binary_54.py b/tests/opcodes/cases/test_or_binary_54.py
index 206e00f9d..bcc11e63d 100644
--- a/tests/opcodes/cases/test_or_binary_54.py
+++ b/tests/opcodes/cases/test_or_binary_54.py
@@ -20,6 +20,6 @@ def test_opcode_or_binary_54(self):
         res = self.i.execute('RUN (Pair 7 7) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 7)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 7)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_packunpack_rev_222.py b/tests/opcodes/cases/test_packunpack_rev_222.py
index e2415d39a..dd3881445 100644
--- a/tests/opcodes/cases/test_packunpack_rev_222.py
+++ b/tests/opcodes/cases/test_packunpack_rev_222.py
@@ -20,6 +20,6 @@ def test_opcode_packunpack_rev_222(self):
         res = self.i.execute('RUN (Pair -1  (Pair 1 (Pair "foobar" (Pair 0x00AABBCC (Pair 1000 (Pair False (Pair "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5" (Pair "2019-09-09T08:35:33Z" "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5")))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_packunpack_rev_223.py b/tests/opcodes/cases/test_packunpack_rev_223.py
index 320501801..043a71793 100644
--- a/tests/opcodes/cases/test_packunpack_rev_223.py
+++ b/tests/opcodes/cases/test_packunpack_rev_223.py
@@ -20,6 +20,6 @@ def test_opcode_packunpack_rev_223(self):
         res = self.i.execute('RUN (Pair -1  (Pair 1 (Pair "foobar" (Pair 0x00AABBCC (Pair 1000 (Pair False (Pair "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5" (Pair "2019-09-09T08:35:33Z" "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5")))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_packunpack_rev_cty_224.py b/tests/opcodes/cases/test_packunpack_rev_cty_224.py
index a06f3ccdf..807c9907e 100644
--- a/tests/opcodes/cases/test_packunpack_rev_cty_224.py
+++ b/tests/opcodes/cases/test_packunpack_rev_cty_224.py
@@ -20,6 +20,6 @@ def test_opcode_packunpack_rev_cty_224(self):
         res = self.i.execute('RUN (Pair "edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav" (Pair Unit (Pair "edsigthTzJ8X7MPmNeEwybRAvdxS1pupqcM5Mk4uCuyZAe7uEk68YpuGDeViW8wSXMrCi5CwoNgqs8V2w8ayB5dMJzrYCHhD8C7" (Pair (Some "edsigthTzJ8X7MPmNeEwybRAvdxS1pupqcM5Mk4uCuyZAe7uEk68YpuGDeViW8wSXMrCi5CwoNgqs8V2w8ayB5dMJzrYCHhD8C7") (Pair { Unit }  (Pair { True }  (Pair (Pair 19 10) (Pair (Left "tz1cxcwwnzENRdhe2Kb8ZdTrdNy4bFNyScx5") (Pair { Elt 0 "foo" ; Elt 1 "bar" }  { PACK } ))))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_packunpack_rev_cty_225.py b/tests/opcodes/cases/test_packunpack_rev_cty_225.py
index ec111decb..ee0e576f9 100644
--- a/tests/opcodes/cases/test_packunpack_rev_cty_225.py
+++ b/tests/opcodes/cases/test_packunpack_rev_cty_225.py
@@ -20,6 +20,6 @@ def test_opcode_packunpack_rev_cty_225(self):
         res = self.i.execute('RUN (Pair "edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav" (Pair Unit (Pair "edsigthTzJ8X7MPmNeEwybRAvdxS1pupqcM5Mk4uCuyZAe7uEk68YpuGDeViW8wSXMrCi5CwoNgqs8V2w8ayB5dMJzrYCHhD8C7" (Pair None (Pair {  }  (Pair {  }  (Pair (Pair 40 -10) (Pair (Right "2019-09-09T08:35:33Z") (Pair {  }  { DUP ; DROP ; PACK } ))))))))) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pair_id_28.py b/tests/opcodes/cases/test_pair_id_28.py
index 0cc34d3b0..10ed81174 100644
--- a/tests/opcodes/cases/test_pair_id_28.py
+++ b/tests/opcodes/cases/test_pair_id_28.py
@@ -20,6 +20,6 @@ def test_opcode_pair_id_28(self):
         res = self.i.execute('RUN (Pair True False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair True False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair True False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pair_id_29.py b/tests/opcodes/cases/test_pair_id_29.py
index e2b70da1d..81e8974fd 100644
--- a/tests/opcodes/cases/test_pair_id_29.py
+++ b/tests/opcodes/cases/test_pair_id_29.py
@@ -20,6 +20,6 @@ def test_opcode_pair_id_29(self):
         res = self.i.execute('RUN (Pair False True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair False True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair False True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pair_id_30.py b/tests/opcodes/cases/test_pair_id_30.py
index 4831b1aa9..5555297b2 100644
--- a/tests/opcodes/cases/test_pair_id_30.py
+++ b/tests/opcodes/cases/test_pair_id_30.py
@@ -20,6 +20,6 @@ def test_opcode_pair_id_30(self):
         res = self.i.execute('RUN (Pair True True) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair True True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair True True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pair_id_31.py b/tests/opcodes/cases/test_pair_id_31.py
index 1b1d49b53..44231f2bf 100644
--- a/tests/opcodes/cases/test_pair_id_31.py
+++ b/tests/opcodes/cases/test_pair_id_31.py
@@ -20,6 +20,6 @@ def test_opcode_pair_id_31(self):
         res = self.i.execute('RUN (Pair False False) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair False False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair False False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pexec_253.py b/tests/opcodes/cases/test_pexec_253.py
index 414b81979..18a5dd121 100644
--- a/tests/opcodes/cases/test_pexec_253.py
+++ b/tests/opcodes/cases/test_pexec_253.py
@@ -20,6 +20,6 @@ def test_opcode_pexec_253(self):
         res = self.i.execute('RUN 38 14')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('52')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('52')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_pexec_2_254.py b/tests/opcodes/cases/test_pexec_2_254.py
index 96ca03c02..176be8f6d 100644
--- a/tests/opcodes/cases/test_pexec_2_254.py
+++ b/tests/opcodes/cases/test_pexec_2_254.py
@@ -20,6 +20,6 @@ def test_opcode_pexec_2_254(self):
         res = self.i.execute('RUN 4 { 0 ; 1 ; 2 ; 3}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0 ; 7 ; 14 ; 21 }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0 ; 7 ; 14 ; 21 }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_ret_int_4.py b/tests/opcodes/cases/test_ret_int_4.py
index 2fe19548e..cc4f0c0a7 100644
--- a/tests/opcodes/cases/test_ret_int_4.py
+++ b/tests/opcodes/cases/test_ret_int_4.py
@@ -20,6 +20,6 @@ def test_opcode_ret_int_4(self):
         res = self.i.execute('RUN Unit None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 300)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 300)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_reverse_8.py b/tests/opcodes/cases/test_reverse_8.py
index 22521cd36..d031ebd80 100644
--- a/tests/opcodes/cases/test_reverse_8.py
+++ b/tests/opcodes/cases/test_reverse_8.py
@@ -20,6 +20,6 @@ def test_opcode_reverse_8(self):
         res = self.i.execute('RUN {} {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_reverse_9.py b/tests/opcodes/cases/test_reverse_9.py
index 56c3bd107..05a4773f8 100644
--- a/tests/opcodes/cases/test_reverse_9.py
+++ b/tests/opcodes/cases/test_reverse_9.py
@@ -20,6 +20,6 @@ def test_opcode_reverse_9(self):
         res = self.i.execute('RUN { "c" ; "b" ; "a" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_reverse_loop_179.py b/tests/opcodes/cases/test_reverse_loop_179.py
index 370d244e6..be63882f6 100644
--- a/tests/opcodes/cases/test_reverse_loop_179.py
+++ b/tests/opcodes/cases/test_reverse_loop_179.py
@@ -20,6 +20,6 @@ def test_opcode_reverse_loop_179(self):
         res = self.i.execute('RUN {} {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_reverse_loop_180.py b/tests/opcodes/cases/test_reverse_loop_180.py
index cc8b9f692..56265c814 100644
--- a/tests/opcodes/cases/test_reverse_loop_180.py
+++ b/tests/opcodes/cases/test_reverse_loop_180.py
@@ -20,6 +20,6 @@ def test_opcode_reverse_loop_180(self):
         res = self.i.execute('RUN { "c" ; "b" ; "a" } {""}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_self_with_default_entrypoint_257.py b/tests/opcodes/cases/test_self_with_default_entrypoint_257.py
index d5be68ac1..c7389b86d 100644
--- a/tests/opcodes/cases/test_self_with_default_entrypoint_257.py
+++ b/tests/opcodes/cases/test_self_with_default_entrypoint_257.py
@@ -20,6 +20,6 @@ def test_opcode_self_with_default_entrypoint_257(self):
         res = self.i.execute('RUN Unit Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_self_with_entrypoint_256.py b/tests/opcodes/cases/test_self_with_entrypoint_256.py
index 17b49699d..c85a25abf 100644
--- a/tests/opcodes/cases/test_self_with_entrypoint_256.py
+++ b/tests/opcodes/cases/test_self_with_entrypoint_256.py
@@ -20,6 +20,6 @@ def test_opcode_self_with_entrypoint_256(self):
         res = self.i.execute('RUN (Left (Left 0)) Unit')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('Unit')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('Unit')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_caddaadr_290.py b/tests/opcodes/cases/test_set_caddaadr_290.py
index 7a0a9e860..44251926e 100644
--- a/tests/opcodes/cases/test_set_caddaadr_290.py
+++ b/tests/opcodes/cases/test_set_caddaadr_290.py
@@ -20,6 +20,6 @@ def test_opcode_set_caddaadr_290(self):
         res = self.i.execute('RUN 3000000 (Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 0) 4) 5))) 6)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 3000000) 4) 5))) 6)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair (Pair 1 (Pair 2 (Pair (Pair (Pair 3 3000000) 4) 5))) 6)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_car_201.py b/tests/opcodes/cases/test_set_car_201.py
index 376823854..fa6ea91ae 100644
--- a/tests/opcodes/cases/test_set_car_201.py
+++ b/tests/opcodes/cases/test_set_car_201.py
@@ -20,6 +20,6 @@ def test_opcode_set_car_201(self):
         res = self.i.execute('RUN "world" (Pair "hello" 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "world" 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "world" 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_car_202.py b/tests/opcodes/cases/test_set_car_202.py
index 13b5566dd..23614c9ef 100644
--- a/tests/opcodes/cases/test_set_car_202.py
+++ b/tests/opcodes/cases/test_set_car_202.py
@@ -20,6 +20,6 @@ def test_opcode_set_car_202(self):
         res = self.i.execute('RUN "abc" (Pair "hello" 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "abc" 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "abc" 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_car_203.py b/tests/opcodes/cases/test_set_car_203.py
index b3726e6f8..99da0583b 100644
--- a/tests/opcodes/cases/test_set_car_203.py
+++ b/tests/opcodes/cases/test_set_car_203.py
@@ -20,6 +20,6 @@ def test_opcode_set_car_203(self):
         res = self.i.execute('RUN "" (Pair "hello" 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "" 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "" 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_cdr_204.py b/tests/opcodes/cases/test_set_cdr_204.py
index 2e1529d2b..3ad4bf3cd 100644
--- a/tests/opcodes/cases/test_set_cdr_204.py
+++ b/tests/opcodes/cases/test_set_cdr_204.py
@@ -20,6 +20,6 @@ def test_opcode_set_cdr_204(self):
         res = self.i.execute('RUN 1 (Pair "hello" 0)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "hello" 1)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "hello" 1)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_cdr_205.py b/tests/opcodes/cases/test_set_cdr_205.py
index dd4257a8f..32d346b67 100644
--- a/tests/opcodes/cases/test_set_cdr_205.py
+++ b/tests/opcodes/cases/test_set_cdr_205.py
@@ -20,6 +20,6 @@ def test_opcode_set_cdr_205(self):
         res = self.i.execute('RUN 3 (Pair "hello" 500)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "hello" 3)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "hello" 3)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_cdr_206.py b/tests/opcodes/cases/test_set_cdr_206.py
index e8274e429..6cb1bb869 100644
--- a/tests/opcodes/cases/test_set_cdr_206.py
+++ b/tests/opcodes/cases/test_set_cdr_206.py
@@ -20,6 +20,6 @@ def test_opcode_set_cdr_206(self):
         res = self.i.execute('RUN 100 (Pair "hello" 7)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair "hello" 100)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair "hello" 100)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_id_131.py b/tests/opcodes/cases/test_set_id_131.py
index cbe06da12..e1361c5d9 100644
--- a/tests/opcodes/cases/test_set_id_131.py
+++ b/tests/opcodes/cases/test_set_id_131.py
@@ -20,6 +20,6 @@ def test_opcode_set_id_131(self):
         res = self.i.execute('RUN { "a" ; "b" ; "c" } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "a" ; "b" ; "c" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_id_132.py b/tests/opcodes/cases/test_set_id_132.py
index f38d24e10..0a5c0d65f 100644
--- a/tests/opcodes/cases/test_set_id_132.py
+++ b/tests/opcodes/cases/test_set_id_132.py
@@ -20,6 +20,6 @@ def test_opcode_set_id_132(self):
         res = self.i.execute('RUN {} {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_id_133.py b/tests/opcodes/cases/test_set_id_133.py
index 8e5c38261..ef30e194e 100644
--- a/tests/opcodes/cases/test_set_id_133.py
+++ b/tests/opcodes/cases/test_set_id_133.py
@@ -20,6 +20,6 @@ def test_opcode_set_id_133(self):
         res = self.i.execute('RUN { "asdf" ; "bcde" } {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ "asdf" ; "bcde" }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ "asdf" ; "bcde" }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_iter_153.py b/tests/opcodes/cases/test_set_iter_153.py
index e0ef2027d..bc704f8f9 100644
--- a/tests/opcodes/cases/test_set_iter_153.py
+++ b/tests/opcodes/cases/test_set_iter_153.py
@@ -20,6 +20,6 @@ def test_opcode_set_iter_153(self):
         res = self.i.execute('RUN {} 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_iter_154.py b/tests/opcodes/cases/test_set_iter_154.py
index fbd91d297..eb88f1e88 100644
--- a/tests/opcodes/cases/test_set_iter_154.py
+++ b/tests/opcodes/cases/test_set_iter_154.py
@@ -20,6 +20,6 @@ def test_opcode_set_iter_154(self):
         res = self.i.execute('RUN { 1 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_iter_155.py b/tests/opcodes/cases/test_set_iter_155.py
index c1b62014a..b6cc43346 100644
--- a/tests/opcodes/cases/test_set_iter_155.py
+++ b/tests/opcodes/cases/test_set_iter_155.py
@@ -20,6 +20,6 @@ def test_opcode_set_iter_155(self):
         res = self.i.execute('RUN { -100 ; 1 ; 2 ; 3 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('-94')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('-94')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_member_146.py b/tests/opcodes/cases/test_set_member_146.py
index 333ebed16..fddc1e21e 100644
--- a/tests/opcodes/cases/test_set_member_146.py
+++ b/tests/opcodes/cases/test_set_member_146.py
@@ -20,6 +20,6 @@ def test_opcode_set_member_146(self):
         res = self.i.execute('RUN "Hi" (Pair {} None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair {} (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair {} (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_member_147.py b/tests/opcodes/cases/test_set_member_147.py
index 4457d920f..6e28052a4 100644
--- a/tests/opcodes/cases/test_set_member_147.py
+++ b/tests/opcodes/cases/test_set_member_147.py
@@ -20,6 +20,6 @@ def test_opcode_set_member_147(self):
         res = self.i.execute('RUN "Hi" (Pair { "Hi" } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { "Hi" } (Some True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { "Hi" } (Some True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_member_148.py b/tests/opcodes/cases/test_set_member_148.py
index dd9b0cb9b..9fd8323fe 100644
--- a/tests/opcodes/cases/test_set_member_148.py
+++ b/tests/opcodes/cases/test_set_member_148.py
@@ -20,6 +20,6 @@ def test_opcode_set_member_148(self):
         res = self.i.execute('RUN "" (Pair { "Hello" ; "World" } None)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair { "Hello" ; "World" } (Some False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair { "Hello" ; "World" } (Some False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_size_149.py b/tests/opcodes/cases/test_set_size_149.py
index 69964fa56..2290405a5 100644
--- a/tests/opcodes/cases/test_set_size_149.py
+++ b/tests/opcodes/cases/test_set_size_149.py
@@ -20,6 +20,6 @@ def test_opcode_set_size_149(self):
         res = self.i.execute('RUN {} 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('0')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('0')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_size_150.py b/tests/opcodes/cases/test_set_size_150.py
index c9febf8db..96ed18c17 100644
--- a/tests/opcodes/cases/test_set_size_150.py
+++ b/tests/opcodes/cases/test_set_size_150.py
@@ -20,6 +20,6 @@ def test_opcode_set_size_150(self):
         res = self.i.execute('RUN { 1 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('1')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('1')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_size_151.py b/tests/opcodes/cases/test_set_size_151.py
index 980dc8220..0b7bc4539 100644
--- a/tests/opcodes/cases/test_set_size_151.py
+++ b/tests/opcodes/cases/test_set_size_151.py
@@ -20,6 +20,6 @@ def test_opcode_set_size_151(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('3')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('3')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_set_size_152.py b/tests/opcodes/cases/test_set_size_152.py
index a5f6fef41..f34ff4d6e 100644
--- a/tests/opcodes/cases/test_set_size_152.py
+++ b/tests/opcodes/cases/test_set_size_152.py
@@ -20,6 +20,6 @@ def test_opcode_set_size_152(self):
         res = self.i.execute('RUN { 1 ; 2 ; 3 ; 4 ; 5 ; 6 } 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('6')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('6')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_73.py b/tests/opcodes/cases/test_shifts_73.py
index 3fee034e8..df809ebad 100644
--- a/tests/opcodes/cases/test_shifts_73.py
+++ b/tests/opcodes/cases/test_shifts_73.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_73(self):
         res = self.i.execute('RUN (Left (Pair 8 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 16)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 16)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_74.py b/tests/opcodes/cases/test_shifts_74.py
index 4f5d80c72..2f5bed0a2 100644
--- a/tests/opcodes/cases/test_shifts_74.py
+++ b/tests/opcodes/cases/test_shifts_74.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_74(self):
         res = self.i.execute('RUN (Left (Pair 0 0)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_75.py b/tests/opcodes/cases/test_shifts_75.py
index a9be89021..03fdc1995 100644
--- a/tests/opcodes/cases/test_shifts_75.py
+++ b/tests/opcodes/cases/test_shifts_75.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_75(self):
         res = self.i.execute('RUN (Left (Pair 0 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_76.py b/tests/opcodes/cases/test_shifts_76.py
index e02460675..e16d9a16f 100644
--- a/tests/opcodes/cases/test_shifts_76.py
+++ b/tests/opcodes/cases/test_shifts_76.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_76(self):
         res = self.i.execute('RUN (Left (Pair 1 2)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 4)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 4)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_77.py b/tests/opcodes/cases/test_shifts_77.py
index b29e400e6..274adc591 100644
--- a/tests/opcodes/cases/test_shifts_77.py
+++ b/tests/opcodes/cases/test_shifts_77.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_77(self):
         res = self.i.execute('RUN (Left (Pair 15 2)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 60)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 60)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_78.py b/tests/opcodes/cases/test_shifts_78.py
index 3f9059119..fd319472f 100644
--- a/tests/opcodes/cases/test_shifts_78.py
+++ b/tests/opcodes/cases/test_shifts_78.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_78(self):
         res = self.i.execute('RUN (Right (Pair 8 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 4)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 4)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_79.py b/tests/opcodes/cases/test_shifts_79.py
index d2b70ed2f..cbc2de44a 100644
--- a/tests/opcodes/cases/test_shifts_79.py
+++ b/tests/opcodes/cases/test_shifts_79.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_79(self):
         res = self.i.execute('RUN (Right (Pair 0 0)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_80.py b/tests/opcodes/cases/test_shifts_80.py
index 729b54c81..749d3e9b5 100644
--- a/tests/opcodes/cases/test_shifts_80.py
+++ b/tests/opcodes/cases/test_shifts_80.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_80(self):
         res = self.i.execute('RUN (Right (Pair 0 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_81.py b/tests/opcodes/cases/test_shifts_81.py
index ed4d75e38..48d803266 100644
--- a/tests/opcodes/cases/test_shifts_81.py
+++ b/tests/opcodes/cases/test_shifts_81.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_81(self):
         res = self.i.execute('RUN (Right (Pair 1 2)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_shifts_82.py b/tests/opcodes/cases/test_shifts_82.py
index dc5475edc..40106b962 100644
--- a/tests/opcodes/cases/test_shifts_82.py
+++ b/tests/opcodes/cases/test_shifts_82.py
@@ -20,6 +20,6 @@ def test_opcode_shifts_82(self):
         res = self.i.execute('RUN (Right (Pair 15 2)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 3)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 3)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_14.py b/tests/opcodes/cases/test_slice_14.py
index 6b4be3a6c..3b39c03a0 100644
--- a/tests/opcodes/cases/test_slice_14.py
+++ b/tests/opcodes/cases/test_slice_14.py
@@ -20,6 +20,6 @@ def test_opcode_slice_14(self):
         res = self.i.execute('RUN (Pair 0 0) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_15.py b/tests/opcodes/cases/test_slice_15.py
index fc86c12c5..559923469 100644
--- a/tests/opcodes/cases/test_slice_15.py
+++ b/tests/opcodes/cases/test_slice_15.py
@@ -20,6 +20,6 @@ def test_opcode_slice_15(self):
         res = self.i.execute('RUN (Pair 10 5) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_16.py b/tests/opcodes/cases/test_slice_16.py
index 369ff0921..e0c1b8885 100644
--- a/tests/opcodes/cases/test_slice_16.py
+++ b/tests/opcodes/cases/test_slice_16.py
@@ -20,6 +20,6 @@ def test_opcode_slice_16(self):
         res = self.i.execute('RUN (Pair 0 0) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_17.py b/tests/opcodes/cases/test_slice_17.py
index c81f8d9af..58cf7574e 100644
--- a/tests/opcodes/cases/test_slice_17.py
+++ b/tests/opcodes/cases/test_slice_17.py
@@ -20,6 +20,6 @@ def test_opcode_slice_17(self):
         res = self.i.execute('RUN (Pair 0 10) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_18.py b/tests/opcodes/cases/test_slice_18.py
index 9a98774e1..1b58f36c9 100644
--- a/tests/opcodes/cases/test_slice_18.py
+++ b/tests/opcodes/cases/test_slice_18.py
@@ -20,6 +20,6 @@ def test_opcode_slice_18(self):
         res = self.i.execute('RUN (Pair 0 2) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "Fo")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "Fo")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_19.py b/tests/opcodes/cases/test_slice_19.py
index 8325a43b1..ff601e967 100644
--- a/tests/opcodes/cases/test_slice_19.py
+++ b/tests/opcodes/cases/test_slice_19.py
@@ -20,6 +20,6 @@ def test_opcode_slice_19(self):
         res = self.i.execute('RUN (Pair 1 3) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_20.py b/tests/opcodes/cases/test_slice_20.py
index 6653a8d77..73d2c273d 100644
--- a/tests/opcodes/cases/test_slice_20.py
+++ b/tests/opcodes/cases/test_slice_20.py
@@ -20,6 +20,6 @@ def test_opcode_slice_20(self):
         res = self.i.execute('RUN (Pair 1 1) (Some "Foo")')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "o")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "o")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_21.py b/tests/opcodes/cases/test_slice_bytes_21.py
index 223269e6b..a23b2f356 100644
--- a/tests/opcodes/cases/test_slice_bytes_21.py
+++ b/tests/opcodes/cases/test_slice_bytes_21.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_21(self):
         res = self.i.execute('RUN (Pair 0 1) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_22.py b/tests/opcodes/cases/test_slice_bytes_22.py
index 790528d66..82d8d75fc 100644
--- a/tests/opcodes/cases/test_slice_bytes_22.py
+++ b/tests/opcodes/cases/test_slice_bytes_22.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_22(self):
         res = self.i.execute('RUN (Pair 0 0) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0x)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0x)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_23.py b/tests/opcodes/cases/test_slice_bytes_23.py
index bf2ea014d..735d8c19b 100644
--- a/tests/opcodes/cases/test_slice_bytes_23.py
+++ b/tests/opcodes/cases/test_slice_bytes_23.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_23(self):
         res = self.i.execute('RUN (Pair 0 1) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0xaa)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0xaa)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_24.py b/tests/opcodes/cases/test_slice_bytes_24.py
index 3cd918a57..b497dc205 100644
--- a/tests/opcodes/cases/test_slice_bytes_24.py
+++ b/tests/opcodes/cases/test_slice_bytes_24.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_24(self):
         res = self.i.execute('RUN (Pair 1 1) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0xbb)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0xbb)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_25.py b/tests/opcodes/cases/test_slice_bytes_25.py
index 77eff5bb3..c32a7c3bb 100644
--- a/tests/opcodes/cases/test_slice_bytes_25.py
+++ b/tests/opcodes/cases/test_slice_bytes_25.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_25(self):
         res = self.i.execute('RUN (Pair 1 2) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0xbbcc)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0xbbcc)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_26.py b/tests/opcodes/cases/test_slice_bytes_26.py
index 46dab69ff..a86dc91b1 100644
--- a/tests/opcodes/cases/test_slice_bytes_26.py
+++ b/tests/opcodes/cases/test_slice_bytes_26.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_26(self):
         res = self.i.execute('RUN (Pair 1 3) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('None')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('None')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_slice_bytes_27.py b/tests/opcodes/cases/test_slice_bytes_27.py
index da699c887..8118ee46c 100644
--- a/tests/opcodes/cases/test_slice_bytes_27.py
+++ b/tests/opcodes/cases/test_slice_bytes_27.py
@@ -20,6 +20,6 @@ def test_opcode_slice_bytes_27(self):
         res = self.i.execute('RUN (Pair 1 1) (Some 0xaabbcc)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some 0xbb)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some 0xbb)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_split_bytes_258.py b/tests/opcodes/cases/test_split_bytes_258.py
index 2d4fb6c4b..ce1932a17 100644
--- a/tests/opcodes/cases/test_split_bytes_258.py
+++ b/tests/opcodes/cases/test_split_bytes_258.py
@@ -20,6 +20,6 @@ def test_opcode_split_bytes_258(self):
         res = self.i.execute('RUN 0xaabbcc {}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0xaa ; 0xbb ; 0xcc }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0xaa ; 0xbb ; 0xcc }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_split_bytes_259.py b/tests/opcodes/cases/test_split_bytes_259.py
index 7c8c3b7e7..fd874c5d6 100644
--- a/tests/opcodes/cases/test_split_bytes_259.py
+++ b/tests/opcodes/cases/test_split_bytes_259.py
@@ -20,6 +20,6 @@ def test_opcode_split_bytes_259(self):
         res = self.i.execute('RUN 0xddeeff { 0xaa ; 0xbb ; 0xcc }')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{ 0xaa ; 0xbb ; 0xcc ; 0xdd ; 0xee ; 0xff }')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{ 0xaa ; 0xbb ; 0xcc ; 0xdd ; 0xee ; 0xff }')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_str_id_12.py b/tests/opcodes/cases/test_str_id_12.py
index adb60c29f..9a4e0ff15 100644
--- a/tests/opcodes/cases/test_str_id_12.py
+++ b/tests/opcodes/cases/test_str_id_12.py
@@ -20,6 +20,6 @@ def test_opcode_str_id_12(self):
         res = self.i.execute('RUN "Hello" None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "Hello")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "Hello")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_str_id_13.py b/tests/opcodes/cases/test_str_id_13.py
index 457a9934c..95ba88cf7 100644
--- a/tests/opcodes/cases/test_str_id_13.py
+++ b/tests/opcodes/cases/test_str_id_13.py
@@ -20,6 +20,6 @@ def test_opcode_str_id_13(self):
         res = self.i.execute('RUN "abcd" None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some "abcd")')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some "abcd")')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_sub_timestamp_delta_215.py b/tests/opcodes/cases/test_sub_timestamp_delta_215.py
index 0c0d64a84..0b8fa8e37 100644
--- a/tests/opcodes/cases/test_sub_timestamp_delta_215.py
+++ b/tests/opcodes/cases/test_sub_timestamp_delta_215.py
@@ -20,6 +20,6 @@ def test_opcode_sub_timestamp_delta_215(self):
         res = self.i.execute('RUN (Pair 100 100) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"1970-01-01T00:00:00Z"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"1970-01-01T00:00:00Z"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_sub_timestamp_delta_216.py b/tests/opcodes/cases/test_sub_timestamp_delta_216.py
index e4f70adce..17e68a448 100644
--- a/tests/opcodes/cases/test_sub_timestamp_delta_216.py
+++ b/tests/opcodes/cases/test_sub_timestamp_delta_216.py
@@ -20,6 +20,6 @@ def test_opcode_sub_timestamp_delta_216(self):
         res = self.i.execute('RUN (Pair 100 -100) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('"1970-01-01T00:03:20Z"')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('"1970-01-01T00:03:20Z"')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_sub_timestamp_delta_217.py b/tests/opcodes/cases/test_sub_timestamp_delta_217.py
index 0b9d959f4..5beea9b0b 100644
--- a/tests/opcodes/cases/test_sub_timestamp_delta_217.py
+++ b/tests/opcodes/cases/test_sub_timestamp_delta_217.py
@@ -20,6 +20,6 @@ def test_opcode_sub_timestamp_delta_217(self):
         res = self.i.execute('RUN (Pair 100 2000000000000000000) 111')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('-1999999999999999900')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('-1999999999999999900')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_tez_add_sub_184.py b/tests/opcodes/cases/test_tez_add_sub_184.py
index d32aaf961..4af363199 100644
--- a/tests/opcodes/cases/test_tez_add_sub_184.py
+++ b/tests/opcodes/cases/test_tez_add_sub_184.py
@@ -20,6 +20,6 @@ def test_opcode_tez_add_sub_184(self):
         res = self.i.execute('RUN (Pair 2000000 1000000) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair 3000000 1000000))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair 3000000 1000000))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_tez_add_sub_185.py b/tests/opcodes/cases/test_tez_add_sub_185.py
index fe4ea6ee5..ba9c5f8e1 100644
--- a/tests/opcodes/cases/test_tez_add_sub_185.py
+++ b/tests/opcodes/cases/test_tez_add_sub_185.py
@@ -20,6 +20,6 @@ def test_opcode_tez_add_sub_185(self):
         res = self.i.execute('RUN (Pair 2310000 1010000) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Pair 3320000 1300000))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Pair 3320000 1300000))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_update_big_map_3.py b/tests/opcodes/cases/test_update_big_map_3.py
index 9e886f037..f36738d5c 100644
--- a/tests/opcodes/cases/test_update_big_map_3.py
+++ b/tests/opcodes/cases/test_update_big_map_3.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_3(self):
         res = self.i.execute('RUN {} (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_update_big_map_4.py b/tests/opcodes/cases/test_update_big_map_4.py
index 51397e3fc..4551103b1 100644
--- a/tests/opcodes/cases/test_update_big_map_4.py
+++ b/tests/opcodes/cases/test_update_big_map_4.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_4(self):
         res = self.i.execute('RUN { Elt "1" (Some "two") } (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'two'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_update_big_map_5.py b/tests/opcodes/cases/test_update_big_map_5.py
index eebf5f62e..1ca7cd37b 100644
--- a/tests/opcodes/cases/test_update_big_map_5.py
+++ b/tests/opcodes/cases/test_update_big_map_5.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_5(self):
         res = self.i.execute('RUN { Elt "3" (Some "three") } (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtzN2y9qBiaf7A14AbS1SveJWXpMdJQztXFgiGzG5yu43tem2he', 'key': {'string': '3'}, 'value': {'string': 'three'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_update_big_map_6.py b/tests/opcodes/cases/test_update_big_map_6.py
index 75fc491e4..9511b5633 100644
--- a/tests/opcodes/cases/test_update_big_map_6.py
+++ b/tests/opcodes/cases/test_update_big_map_6.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_6(self):
         res = self.i.execute('RUN { Elt "3" None } (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtzN2y9qBiaf7A14AbS1SveJWXpMdJQztXFgiGzG5yu43tem2he', 'key': {'string': '3'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_update_big_map_7.py b/tests/opcodes/cases/test_update_big_map_7.py
index b530f5da7..29f79833d 100644
--- a/tests/opcodes/cases/test_update_big_map_7.py
+++ b/tests/opcodes/cases/test_update_big_map_7.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_7(self):
         res = self.i.execute('RUN { Elt "2" None } (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'one'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_update_big_map_8.py b/tests/opcodes/cases/test_update_big_map_8.py
index 25a787352..cc3ebffe1 100644
--- a/tests/opcodes/cases/test_update_big_map_8.py
+++ b/tests/opcodes/cases/test_update_big_map_8.py
@@ -20,9 +20,9 @@ def test_opcode_update_big_map_8(self):
         res = self.i.execute('RUN { Elt "1" (Some "two") } (Pair { Elt "1" "one" ; Elt "2" "two" } Unit)')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Pair 0 Unit)')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Pair 0 Unit)')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = [{'action': 'alloc', 'big_map': '0', 'key_type': {'prim': 'string'}, 'value_type': {'prim': 'string'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprvHK69NiDmfXXw2Gx5x9meBfRp3CBMZ1QjM3UdqoNfUzK3nSpnL', 'key': {'string': '1'}, 'value': {'string': 'two'}}, {'action': 'update', 'big_map': '0', 'key_hash': 'exprtaPfHX9A3HW7vujsuarwHDXwJYu9hJZvuqUCyoeHLRLPXyDQjW', 'key': {'string': '2'}, 'value': {'string': 'two'}}]
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
diff --git a/tests/opcodes/cases/test_xor_63.py b/tests/opcodes/cases/test_xor_63.py
index b2552bbd9..25ca4ae74 100644
--- a/tests/opcodes/cases/test_xor_63.py
+++ b/tests/opcodes/cases/test_xor_63.py
@@ -20,6 +20,6 @@ def test_opcode_xor_63(self):
         res = self.i.execute('RUN (Left (Pair False False)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Left False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Left False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_64.py b/tests/opcodes/cases/test_xor_64.py
index ef6ac0a94..b72ef9403 100644
--- a/tests/opcodes/cases/test_xor_64.py
+++ b/tests/opcodes/cases/test_xor_64.py
@@ -20,6 +20,6 @@ def test_opcode_xor_64(self):
         res = self.i.execute('RUN (Left (Pair False True)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Left True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Left True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_65.py b/tests/opcodes/cases/test_xor_65.py
index 5f6530007..100442a08 100644
--- a/tests/opcodes/cases/test_xor_65.py
+++ b/tests/opcodes/cases/test_xor_65.py
@@ -20,6 +20,6 @@ def test_opcode_xor_65(self):
         res = self.i.execute('RUN (Left (Pair True False)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Left True))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Left True))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_66.py b/tests/opcodes/cases/test_xor_66.py
index 2d087b7b1..8122b6fc8 100644
--- a/tests/opcodes/cases/test_xor_66.py
+++ b/tests/opcodes/cases/test_xor_66.py
@@ -20,6 +20,6 @@ def test_opcode_xor_66(self):
         res = self.i.execute('RUN (Left (Pair True True)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Left False))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Left False))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_67.py b/tests/opcodes/cases/test_xor_67.py
index bee4907ff..18e65fab4 100644
--- a/tests/opcodes/cases/test_xor_67.py
+++ b/tests/opcodes/cases/test_xor_67.py
@@ -20,6 +20,6 @@ def test_opcode_xor_67(self):
         res = self.i.execute('RUN (Right (Pair 0 0)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 0))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 0))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_68.py b/tests/opcodes/cases/test_xor_68.py
index edab2bafd..854ea706d 100644
--- a/tests/opcodes/cases/test_xor_68.py
+++ b/tests/opcodes/cases/test_xor_68.py
@@ -20,6 +20,6 @@ def test_opcode_xor_68(self):
         res = self.i.execute('RUN (Right (Pair 0 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_69.py b/tests/opcodes/cases/test_xor_69.py
index 3b94a66f1..559b6e2e8 100644
--- a/tests/opcodes/cases/test_xor_69.py
+++ b/tests/opcodes/cases/test_xor_69.py
@@ -20,6 +20,6 @@ def test_opcode_xor_69(self):
         res = self.i.execute('RUN (Right (Pair 1 0)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 1))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 1))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_70.py b/tests/opcodes/cases/test_xor_70.py
index ef8e38bbf..cbd487919 100644
--- a/tests/opcodes/cases/test_xor_70.py
+++ b/tests/opcodes/cases/test_xor_70.py
@@ -20,6 +20,6 @@ def test_opcode_xor_70(self):
         res = self.i.execute('RUN (Right (Pair 1 1)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 0))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 0))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_71.py b/tests/opcodes/cases/test_xor_71.py
index ef75f13c4..bcf86404d 100644
--- a/tests/opcodes/cases/test_xor_71.py
+++ b/tests/opcodes/cases/test_xor_71.py
@@ -20,6 +20,6 @@ def test_opcode_xor_71(self):
         res = self.i.execute('RUN (Right (Pair 42 21)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 63))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 63))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/opcodes/cases/test_xor_72.py b/tests/opcodes/cases/test_xor_72.py
index 2e7303227..28abea2e6 100644
--- a/tests/opcodes/cases/test_xor_72.py
+++ b/tests/opcodes/cases/test_xor_72.py
@@ -20,6 +20,6 @@ def test_opcode_xor_72(self):
         res = self.i.execute('RUN (Right (Pair 42 63)) None')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('(Some (Right 21))')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('(Some (Right 21))')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
diff --git a/tests/templates.py b/tests/templates.py
index 9fb5509a4..173e408c8 100644
--- a/tests/templates.py
+++ b/tests/templates.py
@@ -141,9 +141,9 @@ def test_opcode_{case}(self):
         res = self.i.execute('RUN {parameter} {storage}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{expected}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{expected}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
 """
 
 big_map_diff_test_case = """from unittest import TestCase
@@ -168,12 +168,12 @@ def test_opcode_{case}(self):
         res = self.i.execute('RUN {parameter} {storage}')
         self.assertTrue(res['success'])
         
-        expected_expr = michelson_to_micheline('{expected}')
-        expected_val = parse_expression(expected_expr, res['result'][1].type_expr)
-        self.assertEqual(expected_val, res['result'][1]._val)
+        exp_val_expr = michelson_to_micheline('{expected}')
+        exp_val = parse_expression(exp_val_expr, res['result']['storage'].type_expr)
+        self.assertEqual(exp_val, res['result']['storage']._val)
         
         big_map_diff = {big_map_diff}
-        self.assertCountEqual(big_map_diff, res['result'][2])
+        self.assertCountEqual(big_map_diff, res['result']['big_map_diff'])
 """
 
 success_test_case = """from unittest import TestCase