<snip>

    tx_state = message.tx_env.state

    refund_counter = U256(0)

    state_refund = Uint(0)

    target_alive = False

    if message.target == Bytes0(b""):

        if account_deployable(tx_state, message.current_target):

            target_alive = is_account_alive(tx_state, message.current_target)

            evm = process_create_message(message)

        else:

            return MessageCallOutput(

                gas_left=Uint(0),

                refund_counter=U256(0),

                logs=tuple(),

                accounts_to_delete=set(),

                error=AddressCollision(),

                return_data=Bytes(b""),

                state_gas_left=message.state_gas_reservoir,

                regular_gas_used=message.gas,

                state_gas_used=0,

                state_refund=Uint(0),

                created_target_alive=False,

            )

    else:

        if message.tx_env.authorizations != ():

            auth_state_refund, auth_regular_refund = set_delegation(message)

            state_refund += auth_state_refund

            refund_counter += U256(auth_regular_refund)

        delegated_address = get_delegated_code_address(message.code)

        if delegated_address is not None:

            message.disable_precompiles = True

            message.code = get_code(

                tx_state,

                get_account(tx_state, delegated_address).code_hash,

            )

            message.code_address = delegated_address

        evm = process_message(message)

    if evm.error:

        logs: Tuple[Log, ...] = ()

        accounts_to_delete = set()

    else:

        logs = evm.logs

        accounts_to_delete = evm.accounts_to_delete

        refund_counter += U256(evm.refund_counter)

    tx_end = TransactionEnd(

        int(message.gas) - int(evm.gas_left), evm.output, evm.error

    )

    evm_trace(evm, tx_end)

    return MessageCallOutput(

        gas_left=evm.gas_left,

        refund_counter=refund_counter,

        logs=logs,

        accounts_to_delete=accounts_to_delete,

        error=evm.error,

        return_data=evm.output,

        state_gas_left=evm.state_gas_left,

        regular_gas_used=evm.regular_gas_used,

        state_gas_used=frame_state_gas_used(evm),

        state_refund=state_refund,

        created_target_alive=target_alive,

    )

    <snip>

    tx_state = message.tx_env.state

    # take snapshot of state before processing the message

    snapshot = copy_tx_state(tx_state)

    # If the address where the account is being created has storage, it is

    # destroyed. This can only happen in the following highly unlikely

    # circumstances:

    # * The address created by a `CREATE` call collides with a subsequent

    #   `CREATE` or `CREATE2` call.

    # * The first `CREATE` happened before Spurious Dragon and left empty

    #   code.

    destroy_storage(tx_state, message.current_target)

    # In the previously mentioned edge case the preexisting storage is ignored

    # for gas refund purposes. In order to do this we must track created

    # accounts. This tracking is also needed to respect the constraints

    # added to SELFDESTRUCT by EIP-6780.

    mark_account_created(tx_state, message.current_target)

    increment_nonce(tx_state, message.current_target)

    evm = process_message(message)

    if not evm.error:

        contract_code = evm.output

        try:

            if len(contract_code) > 0:

                if contract_code[0] == 0xEF:

                    raise InvalidContractPrefix

            if len(contract_code) > MAX_CODE_SIZE:

                raise OutOfGasError

            # Hash cost for computing keccak256 of deployed bytecode

            code_hash_gas = (

                GasCosts.OPCODE_KECCAK256_PER_WORD

                * ceil32(ulen(contract_code))

                // Uint(32)

            )

            charge_gas(evm, code_hash_gas)

            code_deposit_state_gas = (

                ulen(contract_code) * StateGasCosts.COST_PER_STATE_BYTE

            )

            charge_state_gas(evm, code_deposit_state_gas)

        except ExceptionalHalt as error:

            restore_tx_state(tx_state, snapshot)

            refill_frame_state_gas(evm)

            evm.regular_gas_used += evm.gas_left

            evm.gas_left = Uint(0)

            evm.output = b""

            evm.error = error

        else:

            set_code(tx_state, message.current_target, contract_code)

    else:

        restore_tx_state(tx_state, snapshot)

    return evm

    <snip>

    tx_state = message.tx_env.state

    if message.depth > STACK_DEPTH_LIMIT:

        raise StackDepthLimitError("Stack depth limit reached")

    code = message.code

    valid_jump_destinations = get_valid_jump_destinations(code)

    evm = Evm(

        pc=Uint(0),

        stack=[],

        memory=bytearray(),

        code=code,

        gas_left=message.gas,

        state_gas_left=message.state_gas_reservoir,

        valid_jump_destinations=valid_jump_destinations,

        logs=(),

        refund_counter=0,

        running=True,

        message=message,

        output=b"",

        accounts_to_delete=set(),

        return_data=b"",

        error=None,

        accessed_addresses=message.accessed_addresses,

        accessed_storage_keys=message.accessed_storage_keys,

    )

    snapshot = copy_tx_state(tx_state)

    # Execute message code and handle errors

    try:

        if message.depth == Uint(0) and message.target != Bytes0(b""):

            recipient = message.current_target

            if message.value > U256(0) and not is_account_alive(

                tx_state, recipient

            ):

                charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)

            recipient_code = get_code(

                tx_state, get_account(tx_state, recipient).code_hash

            )

            delegated_address = get_delegated_code_address(recipient_code)

            if delegated_address is not None:

                charge_gas(evm, GasCosts.COLD_ACCOUNT_ACCESS)

                evm.accessed_addresses.add(delegated_address)

        if message.should_transfer_value and message.value != 0:

            move_ether(

                tx_state,

                message.caller,

                message.current_target,

                message.value,

            )

            if message.caller != message.current_target:

                emit_transfer_log(

                    evm,

                    message.caller,

                    message.current_target,

                    message.value,

                )

        if evm.message.code_address in PRE_COMPILED_CONTRACTS:

            if not message.disable_precompiles:

                evm_trace(evm, PrecompileStart(evm.message.code_address))

                PRE_COMPILED_CONTRACTS[evm.message.code_address](evm)

                evm_trace(evm, PrecompileEnd())

        else:

            while evm.running and evm.pc < ulen(evm.code):

                try:

                    op = Ops(evm.code[evm.pc])

                except ValueError as e:

                    raise InvalidOpcode(evm.code[evm.pc]) from e

                evm_trace(evm, OpStart(op))

                op_implementation[op](evm)

                evm_trace(evm, OpEnd())

            evm_trace(evm, EvmStop(Ops.STOP))

    except ExceptionalHalt as error:

        evm_trace(evm, OpException(error))

        refill_frame_state_gas(evm)

        evm.regular_gas_used += evm.gas_left

        evm.gas_left = Uint(0)

        evm.output = b""

        evm.error = error

    except Revert as error:

        evm_trace(evm, OpException(error))

        refill_frame_state_gas(evm)

        evm.error = error

    if evm.error:

        restore_tx_state(tx_state, snapshot)

    return evm