# These imports cause a circular import error

    # if they're not moved inside this method

    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_create

    from ...vm.runtime import get_valid_jump_destinations

    tx_state = evm.tx_env.state

    init_code = memory_read_bytes(

    # PREFLIGHT

    # Abort without spawning the child: nothing has been charged or

    # withheld for it yet.

    sender_address = evm.current_target

    sender = get_account(tx_state, sender_address)

        or evm.depth + Uint(1) > STACK_DEPTH_LIMIT

        push(evm.stack, U256(0))

        return

    # DESTINATION ACCESS

    # The account-creation charge is decided by existence alone,

    # independently of the collision outcome below.

    evm.accessed_addresses.add(contract_address)

    new_account_charged = not is_account_alive(tx_state, contract_address)

    if new_account_charged:

        charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)

    # CHILD GRANT

    # Withhold all but one 64th of the execution gas.

    create_message_gas = withhold_create_gas(evm.gas_meter)

    # On a collision the child's execution-gas grant is consumed and no

    # account is created. A collision target has code or a nonce, so

    # the account-creation charge above was never taken.

    if not account_deployable(tx_state, contract_address):

        increment_nonce(tx_state, sender_address)

    # The whole state gas reservoir rides along (no 63/64 rule for

    # state gas) and is restored when the child returns.

    create_message_state_gas_reservoir = drain_state_gas_reservoir(

        evm.gas_meter

    )

    increment_nonce(tx_state, sender_address)

    # DISPATCH

    child_evm = Evm(

        # Context

        block_env=evm.block_env,

        tx_env=evm.tx_env,

        parent_evm=evm,

        depth=evm.depth + Uint(1),

        # Call Parameters

        caller=evm.current_target,

        current_target=contract_address,

        call_data=b"",

        disable_precompiles=False,

        # Code

        code_address=None,

        code=init_code,

        valid_jump_destinations=get_valid_jump_destinations(init_code),

        # Machine State

        gas_meter=GasMeter(

            gas_left=create_message_gas,

            state_gas_left=create_message_state_gas_reservoir,

            state_gas_baseline=create_message_state_gas_reservoir,

        ),

        pc=Uint(0),

        stack=[],

        memory=bytearray(),

        return_data=b"",

        # Accrued Effects

        logs=(),

        accounts_to_delete=set(),

        accessed_storage_keys=evm.accessed_storage_keys.copy(),

        # Outcome

        running=True,

        output=b"",

        error=None,

    child_evm = process_create(child_evm)

    # OUTCOME

    # The child settled its own gas; absorb it and resolve the

    # account-creation charge by the state's fate: it refills when a

    # charged creation failed.

    incorporate_child(evm, child_evm)

        if new_account_charged:

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.NEW_ACCOUNT)

        evm.return_data = b""

        push(evm.stack, U256.from_be_bytes(child_evm.current_target))

    # This import causes a circular import error

    # if it's not moved inside this method

    from ...vm.interpreter import MAX_INIT_CODE_SIZE

    if evm.is_static:

        raise WriteInStaticContext

        GasCosts.CREATE_ACCESS + extend_memory.cost + init_code_gas,

    if memory_size > U256(MAX_INIT_CODE_SIZE):

        raise OutOfGasError

        evm.current_target,

        get_account(evm.tx_env.state, evm.current_target).nonce,

    # This import causes a circular import error

    # if it's not moved inside this method

    from ...vm.interpreter import MAX_INIT_CODE_SIZE

    if evm.is_static:

        raise WriteInStaticContext

        ExecutionGas(

            GasCosts.CREATE_ACCESS

            + GasCosts.OPCODE_KECCAK256_PER_WORD * call_data_words

            + extend_memory.cost

            + init_code_gas

        ),

    if memory_size > U256(MAX_INIT_CODE_SIZE):

        raise OutOfGasError

        evm.current_target,

    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_call

    from ...vm.runtime import get_valid_jump_destinations

    # PREFLIGHT

    # Abort without spawning the child: both grants return untouched

    # and any account-creation charge refills.

    if evm.depth + Uint(1) > STACK_DEPTH_LIMIT or params.insufficient_balance:

        restore_child_gas(

            evm.gas_meter, params.gas, params.state_gas_reservoir

        )

        if params.new_account_charged:

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.NEW_ACCOUNT)

    # DISPATCH

    call_data = memory_read_bytes(

    child_evm = Evm(

        # Context

        block_env=evm.block_env,

        tx_env=evm.tx_env,

        parent_evm=evm,

        depth=evm.depth + Uint(1),

        # Call Parameters

        current_target=params.to,

        call_data=call_data,

        should_transfer_value=params.should_transfer_value,

        is_static=params.is_staticcall or evm.is_static,

        disable_precompiles=params.disable_precompiles,

        # Code

        code_address=params.code_address,

        valid_jump_destinations=get_valid_jump_destinations(params.code),

        # Machine State

        gas_meter=GasMeter(

            gas_left=params.gas,

            state_gas_left=params.state_gas_reservoir,

            state_gas_baseline=params.state_gas_reservoir,

        ),

        pc=Uint(0),

        stack=[],

        memory=bytearray(),

        return_data=b"",

        # Accrued Effects

        logs=(),

        accounts_to_delete=set(),

        accessed_storage_keys=evm.accessed_storage_keys.copy(),

        # Outcome

        running=True,

        output=b"",

        error=None,

    child_evm = process_call(child_evm)

    # OUTCOME

    # The child settled its own gas; absorb it and resolve the

    # account-creation charge by the state's fate.

    incorporate_child(evm, child_evm)

    evm.return_data = child_evm.output

        if params.new_account_charged:

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.NEW_ACCOUNT)

        push(evm.stack, CALL_SUCCESS)

    gas = ExecutionGas(Uint(pop(evm.stack)))

    if evm.is_static and value != U256(0):

        raise WriteInStaticContext

    # GAS (STATE-INDEPENDENT)

    # Price what is computable without touching state, and check it is

    # affordable before any state access is performed.

    is_cold_access = to not in evm.accessed_addresses

    if is_cold_access:

        access_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS

        access_gas_cost = GasCosts.WARM_ACCESS

    transfer_gas_cost = GasCosts.ZERO if value == 0 else GasCosts.CALL_VALUE

    check_gas(

        evm,

        access_gas_cost + transfer_gas_cost + extend_memory.cost,

    )

    # STATE ACCESS (STATE-DEPENDENT GAS)

    # Perform the accesses and complete the state-dependent pricing --

    # a delegation adds its access cost -- then charge the execution

    # gas.

    tx_state = evm.tx_env.state

    if is_cold_access:

        evm.accessed_addresses.add(to)

    extra_gas = access_gas_cost + transfer_gas_cost

        is_delegated,

        delegation_access_cost,

    ) = calculate_delegation_cost(evm, to)

    if is_delegated:

        # check enough gas for delegation access

        extra_gas += delegation_access_cost

        check_gas(evm, extra_gas + extend_memory.cost)

        if code_address not in evm.accessed_addresses:

            evm.accessed_addresses.add(code_address)

    code_hash = get_account(tx_state, code_address).code_hash

    code = get_code(tx_state, code_hash)

    charge_gas(evm, extra_gas + extend_memory.cost)

    # STATE GAS

    # A value transfer that will create the recipient is charged by

    # the frame whose opcode causes it; refilled in `generic_call`

    # whenever the creation fails or never happens.

    has_value = value != 0

    new_account_charged = has_value and not is_account_alive(tx_state, to)

    if new_account_charged:

        charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)

    # CHILD GRANT

    # Computed after every charge above, so any state-gas spill has

    # already thinned `gas_left`. The whole reservoir rides along (no

    # 63/64 rule for state gas).

    message_call_gas = calculate_message_call_gas(

        evm.gas_meter.gas_left,

        memory_cost=GasCosts.ZERO,

        extra_gas=GasCosts.ZERO,