<snip>

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

        evm.memory, memory_start_position, memory_size

    )

    evm.return_data = b""

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

    if (

        sender.balance < endowment

        or sender.nonce == Uint(2**64 - 1)

        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)

        push(evm.stack, U256(0))

        return

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

        value=endowment,

        call_data=b"",

        should_transfer_value=True,

        is_static=False,

        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_addresses=evm.accessed_addresses.copy(),

        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 child_evm.error:

        if new_account_charged:

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.NEW_ACCOUNT)

        evm.return_data = child_evm.output

        push(evm.stack, U256(0))

    else:

        evm.return_data = b""

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

    <snip>

    # 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

    # STACK

    endowment = pop(evm.stack)

    memory_start_position = pop(evm.stack)

    memory_size = pop(evm.stack)

    # GAS

    extend_memory = calculate_gas_extend_memory(

        evm.memory, [(memory_start_position, memory_size)]

    )

    init_code_gas = init_code_cost(Uint(memory_size))

    charge_gas(

        evm,

        GasCosts.CREATE_ACCESS + extend_memory.cost + init_code_gas,

    )

    if memory_size > U256(MAX_INIT_CODE_SIZE):

        raise OutOfGasError

    # OPERATION

    evm.memory += b"\x00" * extend_memory.expand_by

    contract_address = compute_contract_address(

        evm.current_target,

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

    )

    generic_create(

        evm,

        endowment,

        contract_address,

        memory_start_position,

        memory_size,

    )

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    # 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

    # STACK

    endowment = pop(evm.stack)

    memory_start_position = pop(evm.stack)

    memory_size = pop(evm.stack)

    salt = pop(evm.stack).to_be_bytes32()

    # GAS

    extend_memory = calculate_gas_extend_memory(

        evm.memory, [(memory_start_position, memory_size)]

    )

    call_data_words = ceil32(Uint(memory_size)) // Uint(32)

    init_code_gas = init_code_cost(Uint(memory_size))

    charge_gas(

        evm,

        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

    # OPERATION

    evm.memory += b"\x00" * extend_memory.expand_by

    contract_address = compute_create2_contract_address(

        evm.current_target,

        salt,

        memory_read_bytes(evm.memory, memory_start_position, memory_size),

    )

    generic_create(

        evm,

        endowment,

        contract_address,

        memory_start_position,

        memory_size,

    )

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    # STACK

    memory_start_position = pop(evm.stack)

    memory_size = pop(evm.stack)

    # GAS

    extend_memory = calculate_gas_extend_memory(

        evm.memory, [(memory_start_position, memory_size)]

    )

    charge_gas(evm, GasCosts.ZERO + extend_memory.cost)

    # OPERATION

    evm.memory += b"\x00" * extend_memory.expand_by

    evm.output = memory_read_bytes(

        evm.memory, memory_start_position, memory_size

    )

    evm.running = False

    # PROGRAM COUNTER

    pass

    <snip>

    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_call

    from ...vm.runtime import get_valid_jump_destinations

    evm.return_data = b""

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

        push(evm.stack, U256(0))

        return

    # DISPATCH

    call_data = memory_read_bytes(

        evm.memory,

        params.memory_input_start_position,

        params.memory_input_size,

    )

    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=params.caller,

        current_target=params.to,

        value=params.value,

        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,

        code=params.code,

        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_addresses=evm.accessed_addresses.copy(),

        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 child_evm.error:

        if params.new_account_charged:

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.NEW_ACCOUNT)

        push(evm.stack, U256(0))

    else:

        push(evm.stack, CALL_SUCCESS)

    actual_output_size = min(

        params.memory_output_size, U256(len(child_evm.output))

    )

    memory_write(

        evm.memory,

        params.memory_output_start_position,

        child_evm.output[:actual_output_size],

    )

    <snip>

    # STACK

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

    to = to_address_masked(pop(evm.stack))

    value = pop(evm.stack)

    memory_input_start_position = pop(evm.stack)

    memory_input_size = pop(evm.stack)

    memory_output_start_position = pop(evm.stack)

    memory_output_size = 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.

    extend_memory = calculate_gas_extend_memory(

        evm.memory,

        [

            (memory_input_start_position, memory_input_size),

            (memory_output_start_position, memory_output_size),

        ],

    )

    is_cold_access = to not in evm.accessed_addresses

    if is_cold_access:

        access_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS

    else:

        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,

        code_address,

        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(

        value,

        gas,

        evm.gas_meter.gas_left,

        memory_cost=GasCosts.ZERO,

        extra_gas=GasCosts.ZERO,

    )

    charge_gas(evm, message_call_gas.cost)

    call_state_gas_reservoir = drain_state_gas_reservoir(evm.gas_meter)

    # OPERATION

    evm.memory += b"\x00" * extend_memory.expand_by

    sender_balance = get_account(tx_state, evm.current_target).balance

    generic_call(

        evm,

        GenericCall(

            gas=message_call_gas.sub_call,

            state_gas_reservoir=call_state_gas_reservoir,

            value=value,

            caller=evm.current_target,

            to=to,

            code_address=code_address,

            should_transfer_value=True,

            is_staticcall=False,

            memory_input_start_position=memory_input_start_position,

            memory_input_size=memory_input_size,

            memory_output_start_position=memory_output_start_position,

            memory_output_size=memory_output_size,

            code=code,

            disable_precompiles=is_delegated,

            new_account_charged=new_account_charged,

            insufficient_balance=sender_balance < value,

        ),

    )

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    # STACK

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

    code_address = to_address_masked(pop(evm.stack))

    value = pop(evm.stack)

    memory_input_start_position = pop(evm.stack)

    memory_input_size = pop(evm.stack)

    memory_output_start_position = pop(evm.stack)

    memory_output_size = pop(evm.stack)

    # GAS (STATE-INDEPENDENT)

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

    # affordable before any state access is performed.

    to = evm.current_target

    extend_memory = calculate_gas_extend_memory(

        evm.memory,

        [

            (memory_input_start_position, memory_input_size),

            (memory_output_start_position, memory_output_size),

        ],

    )

    is_cold_access = code_address not in evm.accessed_addresses

    if is_cold_access:

        access_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS

    else:

        access_gas_cost = GasCosts.WARM_ACCESS

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

    check_gas(

        evm,

        access_gas_cost + extend_memory.cost + transfer_gas_cost,

    )

    # STATE ACCESS (STATE-DEPENDENT GAS)

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

    # a delegation adds its access cost; the execution gas is charged

    # with the child grant.

    tx_state = evm.tx_env.state

    if is_cold_access:

        evm.accessed_addresses.add(code_address)

    extra_gas = access_gas_cost + transfer_gas_cost

    (

        is_delegated,

        code_address,

        delegation_access_cost,

    ) = calculate_delegation_cost(evm, code_address)

    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)

    # CHILD GRANT

    # Charge the call's cost and withhold the child's execution gas

    # share in one step. The whole reservoir rides along (no 63/64

    # rule for state gas).

    message_call_gas = calculate_message_call_gas(

        value,

        gas,

        evm.gas_meter.gas_left,

        extend_memory.cost,

        extra_gas,

    )

    charge_gas(evm, message_call_gas.cost + extend_memory.cost)

    call_state_gas_reservoir = drain_state_gas_reservoir(evm.gas_meter)

    # OPERATION

    evm.memory += b"\x00" * extend_memory.expand_by

    sender_balance = get_account(tx_state, evm.current_target).balance

    generic_call(

        evm,

        GenericCall(

            gas=message_call_gas.sub_call,

            state_gas_reservoir=call_state_gas_reservoir,

            value=value,

            caller=evm.current_target,

            to=to,