<snip>

    # STACK

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

    # GAS

    if (evm.current_target, key) in evm.accessed_storage_keys:

        charge_gas(evm, GasCosts.WARM_ACCESS)

    else:

        evm.accessed_storage_keys.add((evm.current_target, key))

        charge_gas(evm, GasCosts.COLD_STORAGE_ACCESS)

    # OPERATION

    tx_state = evm.tx_env.state

    value = get_storage(tx_state, evm.current_target, key)

    push(evm.stack, value)

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    if evm.is_static:

        raise WriteInStaticContext

    # STACK

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

    new_value = pop(evm.stack)

    # GAS (STATE-INDEPENDENT)

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

    # affordable before any state access is performed.

    gas_cost = GasCosts.ZERO

    # Access cost: cold or warm, always charged.

    is_cold_access = (

        evm.current_target,

        key,

    ) not in evm.accessed_storage_keys

    if is_cold_access:

        gas_cost += GasCosts.COLD_STORAGE_ACCESS

    else:

        gas_cost += GasCosts.WARM_ACCESS

    # EIP-2200 stipend sentry, checked before the state access below

    # records the slot read in the Block Access List. The `max` guards an

    # access cost repriced above the stipend; neither warmth is today.

    check_gas(

        evm, max(gas_cost, ExecutionGas(GasCosts.CALL_STIPEND + Uint(1)))

    )

    # STATE ACCESS (STATE-DEPENDENT GAS)

    # Perform the access and complete the state-dependent pricing from

    # the slot's original and current values, adjusting the

    # transaction's refunds.

    if is_cold_access:

        evm.accessed_storage_keys.add((evm.current_target, key))

    tx_state = evm.tx_env.state

    original_value = get_storage_original(tx_state, evm.current_target, key)

    current_value = get_storage(tx_state, evm.current_target, key)

    state_gas = StateGas(Uint(0))

    # Write cost: charged each time the slot moves away from its

    # transaction-start value; restoring it refunds the charge below.

    if original_value == current_value and current_value != new_value:

        gas_cost += GasCosts.STORAGE_WRITE

    # Refund Counter Calculation

    if current_value != new_value:

        if original_value != 0 and current_value != 0 and new_value == 0:

            # Slot non-zero at transaction start is cleared; granted on

            # each such clear.

            evm.gas_meter.refund_counter += GasCosts.REFUND_STORAGE_CLEAR

        if original_value != 0 and current_value == 0:

            # Gas refund issued earlier to be reversed

            evm.gas_meter.refund_counter -= GasCosts.REFUND_STORAGE_CLEAR

        if original_value == new_value:

            # Slot restored to its original value: refund the

            # STORAGE_WRITE charged when it was moved away.

            evm.gas_meter.refund_counter += int(GasCosts.STORAGE_WRITE)

    # STATE GAS

    # A first-time set of a zero slot pays for the state it creates; a

    # slot set then cleared refills the earlier charge.

    if original_value == current_value and current_value != new_value:

        if original_value == 0:

            state_gas = StateGasCosts.STORAGE_SET

    if current_value != new_value and original_value == new_value:

        if original_value == 0:

            # Slot set then cleared: refund the state gas charge.

            credit_state_gas_refund(evm.gas_meter, StateGasCosts.STORAGE_SET)

    # Charge execution gas before state gas so that an execution-gas

    # OOG does not consume state gas that would inflate the parent's

    # reservoir on frame failure.

    charge_gas(evm, gas_cost)

    charge_state_gas(evm, state_gas)

    set_storage(tx_state, evm.current_target, key, new_value)

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    # STACK

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

    # GAS

    charge_gas(evm, GasCosts.OPCODE_TLOAD)

    # OPERATION

    value = get_transient_storage(evm.tx_env.state, evm.current_target, key)

    push(evm.stack, value)

    # PROGRAM COUNTER

    evm.pc += Uint(1)

    <snip>

    if evm.is_static:

        raise WriteInStaticContext

    # STACK

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

    new_value = pop(evm.stack)

    # GAS

    charge_gas(evm, GasCosts.OPCODE_TSTORE)

    set_transient_storage(

        evm.tx_env.state,

        evm.current_target,

        key,

        new_value,

    )

    # PROGRAM COUNTER

    evm.pc += Uint(1)