"""

    If `message.target` is empty then it creates a smart contract

    else it executes a call from the `message.caller` to the `message.target`.

    Parameters

    ----------

    message :

        Transaction specific items.

    Returns

    -------

    output : `MessageCallOutput`

        Output of the message call

    """

    block_env = message.block_env

    refund_counter = U256(0)

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

        is_collision = account_has_code_or_nonce(

            block_env.state, message.current_target

        ) or account_has_storage(block_env.state, message.current_target)

        if is_collision:

            return MessageCallOutput(

                gas_left=Uint(0),

                refund_counter=U256(0),

                logs=tuple(),

                accounts_to_delete=set(),

                touched_accounts=set(),

                error=AddressCollision(),

            )

        else:

            evm = process_create_message(message)

    else:

        evm = process_message(message)

        if account_exists_and_is_empty(

            block_env.state, Address(message.target)

        ):

            evm.touched_accounts.add(Address(message.target))

    if evm.error:

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

        accounts_to_delete = set()

        touched_accounts = set()

    else:

        logs = evm.logs

        accounts_to_delete = evm.accounts_to_delete

        touched_accounts = evm.touched_accounts

        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,

        touched_accounts=touched_accounts,

        error=evm.error,

    )

    """

    Executes a call to create a smart contract.

    Parameters

    ----------

    message :

        Transaction specific items.

    Returns

    -------

    evm: :py:class:`~ethereum.forks.berlin.vm.Evm`

        Items containing execution specific objects.

    """

    state = message.block_env.state

    # take snapshot of state before processing the message

    begin_transaction(state)

    # The list of created accounts is used by `get_storage_original`.

    mark_account_created(state, message.current_target)

    increment_nonce(state, message.current_target)

    evm = process_message(message)

    if not evm.error:

        contract_code = evm.output

        contract_code_gas = (

            Uint(len(contract_code)) * GAS_CODE_DEPOSIT_PER_BYTE

        )

        try:

            charge_gas(evm, contract_code_gas)

            if len(contract_code) > MAX_CODE_SIZE:

                raise OutOfGasError

        except ExceptionalHalt as error:

            rollback_transaction(state)

            evm.gas_left = Uint(0)

            evm.output = b""

            evm.error = error

        else:

            set_code(state, message.current_target, contract_code)

            commit_transaction(state)

    else:

        rollback_transaction(state)

    return evm

    """

    Move ether and execute the relevant code.

    Parameters

    ----------

    message :

        Transaction specific items.

    Returns

    -------

    evm: :py:class:`~ethereum.forks.berlin.vm.Evm`

        Items containing execution specific objects

    """

    state = message.block_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,

        valid_jump_destinations=valid_jump_destinations,

        logs=(),

        refund_counter=0,

        running=True,

        message=message,

        output=b"",

        accounts_to_delete=set(),

        touched_accounts=set(),

        return_data=b"",

        error=None,

        accessed_addresses=message.accessed_addresses,

        accessed_storage_keys=message.accessed_storage_keys,

    )

    # take snapshot of state before processing the message

    begin_transaction(state)

    touch_account(state, message.current_target)

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

        move_ether(

            state, message.caller, message.current_target, message.value

        )

    try:

        if evm.message.code_address in PRE_COMPILED_CONTRACTS:

            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))

        evm.gas_left = Uint(0)

        evm.output = b""

        evm.error = error

    except Revert as error:

        evm_trace(evm, OpException(error))

        evm.error = error

    if evm.error:

        # revert state to the last saved checkpoint

        # since the message call resulted in an error

        rollback_transaction(state)

    else:

        commit_transaction(state)

    return evm