tx_state = message.tx_env.state

        is_collision = account_has_code_or_nonce(

            tx_state, message.current_target

        ) or account_has_storage(tx_state, message.current_target)

                state_gas_reservoir=Uint(0),

                regular_gas_used=Uint(0),

                state_gas_used=0,

            evm = process_message(message, True)

            set_delegation(message)

            message.code = get_code(

                tx_state,

                get_account(tx_state, delegated_address).code_hash,

        evm = process_message(message, False)

        refund_counter += U256(evm.refund_counter)

        # Deferred SELFDESTRUCT processing per EIP-8037 + EIP-6780.

        # SELFDESTRUCT queues the originator into `accounts_to_delete` at

        # opcode time; the actual `destroy_account` runs at the top-level

        # frame to deduplicate (an account SELFDESTRUCTed multiple times

        # is destroyed once) and to integrate with revert (child

        # SELFDESTRUCTs in a reverted ancestor are dropped via

        # `incorporate_child_on_error`).

        #

        # Per EIP-6780 only same-tx-created accounts are actually

        # removed. The frame-end diff above charged for the create

        # (account record, deployed code, new storage slots); refund

        # those here directly to the reservoir (no 20% cap), then

        # allow the loop in fork.py to destroy the account.

        for address in evm.accounts_to_delete:

            if address in tx_state.created_accounts:

                account = get_account(tx_state, address)

                code = get_code(tx_state, account.code_hash)

                refund_bytes = int(StateCosts.NEW_ACCOUNT) + len(code)

                for slot_value in tx_state.storage_writes.get(

                    address, {}

                ).values():

                    if slot_value != U256(0):

                        refund_bytes += int(StateCosts.STORAGE_SET)

                refill_amount = refund_bytes * int(StateCosts.PER_BYTE)

                # Per EIP-8037: refill `state_gas_reservoir` with

                # the previously-charged state gas (account creation,

                # code deposit, new storage slots), and decrease

                # `execution_state_gas_used` by the same amount. The

                # decrement may go negative because the account-

                # creation portion was charged via

                # `intrinsic_state_gas` (not via this counter); the

                # negative offsets the intrinsic at block-level

                # `tx_state_gas` accounting.

                evm.state_gas_reservoir += Uint(refill_amount)

                evm.state_gas_used -= refill_amount

        state_gas_reservoir=evm.state_gas_reservoir,

        regular_gas_used=evm.regular_gas_used,

        state_gas_used=evm.state_gas_used,

    create  :

        Whether the message is contract-creating.

    include_account_creation_in_diff  :

        Whether to include account creation in the diff to calculate state gas.

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

    tx_state = message.tx_env.state

        state_gas_reservoir=message.state_gas_reservoir,

    revert_snapshot = copy_tx_state(tx_state)

    if create:

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

        # CALL-with-value to a non-existent address creates the

        # target account when `move_ether` deposits the balance. The

        # account creation surfaces in `tx_state.account_writes` and

        # is picked up by `compute_state_byte_diff` at this frame's

        # frame-end (or rolled back by `restore_tx_state` on error).

        move_ether(

            tx_state,

            message.caller,

            message.current_target,

            message.value,

        )

        # EIP-7708: Only emit transfer log to a different account

        if message.caller != message.current_target:

            emit_transfer_log(

                evm, message.caller, message.current_target, message.value

            )

    diff_snapshot = copy_tx_state(tx_state)

            evm_trace(evm, EvmStop(Ops.STOP))

        if create:

            contract_code = evm.output

            if len(contract_code) > 0:

                if contract_code[0] == 0xEF:

                    raise InvalidContractPrefix

            if len(contract_code) > MAX_CODE_SIZE:

                raise OutOfGasError

            # The legacy per-byte code-deposit cost (200 gas/byte) is

            # gone; deposited bytes now pay through the state-byte

            # counter (`+len(contract_code)` below) at frame-end via

            # `× PER_BYTE`. The only regular-gas cost retained for

            # code deposit is the keccak256 hashing of the deployed

            # bytecode, since that's a real per-word CPU cost the

            # client incurs to derive `code_hash`.

            code_hash_gas = (

                GasCosts.OPCODE_KECCACK256_PER_WORD

                * ceil32(ulen(contract_code))

                // Uint(32)

            )

            charge_gas(evm, code_hash_gas)

            set_code(tx_state, message.current_target, contract_code)

        # Frame-end state-gas settlement.

        apply_frame_state_gas(evm, diff_snapshot, message)

        # On exceptional halt the frame consumes all remaining

        # `gas_left`. Spill that into `regular_gas_used` so the

        # parent's `incorporate_child_on_error` sees the full

        # regular-gas burn (otherwise the forfeited remainder would

        # be lost from the per-tx total). State gas isn't touched

        # here — `incorporate_child_on_error` returns the child's

        # state-gas budget (used + unused) to the parent reservoir,

        # since the rolled-back state never grew.

        evm.regular_gas_used += evm.gas_left

        # State gas is preserved on exceptional halt so it can be

        # returned to the parent frame via incorporate_child_on_error.

        evm.output = b""

        # REVERT preserves remaining `gas_left` (refunded to the

        # parent via `incorporate_child_on_error`); only the error

        # is recorded here.

        evm_trace(evm, OpException(error))

        restore_tx_state(tx_state, revert_snapshot)