"""

    Checks if `amount` gas is available without charging it.

    Raises OutOfGasError if insufficient gas.

    Parameters

    ----------

    evm :

        The current EVM.

    amount :

        The amount of gas to check.

    """

    if evm.gas_left < amount:

        raise OutOfGasError

    """

    Subtracts `amount` from `evm.gas_left` (regular gas) and records usage.

    Parameters

    ----------

    evm :

        The current EVM.

    amount :

        The amount of regular gas the current operation requires.

    """

    evm_trace(evm, GasAndRefund(int(amount)))

    if evm.gas_left < amount:

        raise OutOfGasError

    evm.gas_left -= amount

    evm.regular_gas_used += amount

    """

    Calculates the gas cost for allocating memory

    to the smallest multiple of 32 bytes,

    such that the allocated size is at least as big as the given size.

    Parameters

    ----------

    size_in_bytes :

        The size of the data in bytes.

    Returns

    -------

    total_gas_cost : `ethereum.base_types.Uint`

        The gas cost for storing data in memory.

    """

    size_in_words = ceil32(size_in_bytes) // Uint(32)

    linear_cost = size_in_words * GasCosts.MEMORY_PER_WORD

    quadratic_cost = size_in_words ** Uint(2) // Uint(512)

    total_gas_cost = linear_cost + quadratic_cost

    try:

        return total_gas_cost

    except ValueError as e:

        raise OutOfGasError from e

    """

    Calculates the gas amount to extend memory.

    Parameters

    ----------

    memory :

        Memory contents of the EVM.

    extensions:

        List of extensions to be made to the memory.

        Consists of a tuple of start position and size.

    Returns

    -------

    extend_memory: `ExtendMemory`

    """

    size_to_extend = Uint(0)

    to_be_paid = Uint(0)

    current_size = ulen(memory)

    for start_position, size in extensions:

        if size == 0:

            continue

        before_size = ceil32(current_size)

        after_size = ceil32(Uint(start_position) + Uint(size))

        if after_size <= before_size:

            continue

        size_to_extend += after_size - before_size

        already_paid = calculate_memory_gas_cost(before_size)

        total_cost = calculate_memory_gas_cost(after_size)

        to_be_paid += total_cost - already_paid

        current_size = after_size

    return ExtendMemory(to_be_paid, size_to_extend)

    """

    Calculates the MessageCallGas (cost and gas made available to the sub-call)

    for executing call Opcodes.

    Parameters

    ----------

    value:

        The amount of `ETH` that needs to be transferred.

    gas :

        The amount of gas provided to the message-call.

    gas_left :

        The amount of gas left in the current frame.

    memory_cost :

        The amount needed to extend the memory in the current frame.

    extra_gas :

        The amount of gas needed for transferring value + creating a new

        account inside a message call.

    call_stipend :

        The amount of stipend provided to a message call to execute code while

        transferring value (ETH).

    Returns

    -------

    message_call_gas: `MessageCallGas`

    """

    call_stipend = Uint(0) if value == 0 else call_stipend

    if gas_left < extra_gas + memory_cost:

        return MessageCallGas(gas + extra_gas, gas + call_stipend)

    gas = min(gas, max_message_call_gas(gas_left - memory_cost - extra_gas))

    return MessageCallGas(gas + extra_gas, gas + call_stipend)

    """

    Calculates the maximum gas that is allowed for making a message call.

    Parameters

    ----------

    gas :

        The amount of gas provided to the message-call.

    Returns

    -------

    max_allowed_message_call_gas: `ethereum.base_types.Uint`

        The maximum gas allowed for making the message-call.

    """

    return gas - (gas // Uint(64))

    """

    Calculates the gas to be charged for the init code in CREATE*

    opcodes as well as create transactions.

    Parameters

    ----------

    init_code_length :

        The length of the init code provided to the opcode

        or a create transaction

    Returns

    -------

    init_code_gas: `ethereum.base_types.Uint`

        The gas to be charged for the init code.

    """

    return GasCosts.CODE_INIT_PER_WORD * ceil32(init_code_length) // Uint(32)

    """

    Calculates the excess blob gas for the current block based

    on the gas used in the parent block.

    Parameters

    ----------

    parent_header :

        The parent block of the current block.

    Returns

    -------

    excess_blob_gas: `ethereum.base_types.U64`

        The excess blob gas for the current block.

    """

    # At the fork block, these are defined as zero.

    excess_blob_gas = U64(0)

    blob_gas_used = U64(0)

    base_fee_per_gas = Uint(0)

    if isinstance(parent_header, Header):

        # After the fork block, read them from the parent header.

        excess_blob_gas = parent_header.excess_blob_gas

        blob_gas_used = parent_header.blob_gas_used

        base_fee_per_gas = parent_header.base_fee_per_gas

    parent_blob_gas = excess_blob_gas + blob_gas_used

    if parent_blob_gas < GasCosts.BLOB_TARGET_GAS_PER_BLOCK:

        return U64(0)

    target_blob_gas_price = Uint(GasCosts.PER_BLOB)

    target_blob_gas_price *= calculate_blob_gas_price(excess_blob_gas)

    base_blob_tx_price = GasCosts.BLOB_BASE_COST * base_fee_per_gas

    if base_blob_tx_price > target_blob_gas_price:

        blob_schedule_delta = (

            GasCosts.BLOB_SCHEDULE_MAX - GasCosts.BLOB_SCHEDULE_TARGET

        )

        return (

            excess_blob_gas

            + blob_gas_used * blob_schedule_delta // GasCosts.BLOB_SCHEDULE_MAX

        )

    return parent_blob_gas - GasCosts.BLOB_TARGET_GAS_PER_BLOCK

    """

    Calculate the total blob gas for a transaction.

    Parameters

    ----------

    tx :

        The transaction for which the blob gas is to be calculated.

    Returns

    -------

    total_blob_gas: `ethereum.base_types.Uint`

        The total blob gas for the transaction.

    """

    if isinstance(tx, BlobTransaction):

        return GasCosts.PER_BLOB * U64(len(tx.blob_versioned_hashes))

    else:

        return U64(0)

    """

    Calculate the blob gasprice for a block.

    Parameters

    ----------

    excess_blob_gas :

        The excess blob gas for the block.

    Returns

    -------

    blob_gasprice: `Uint`

        The blob gasprice.

    """

    return taylor_exponential(

        GasCosts.BLOB_MIN_GASPRICE,

        Uint(excess_blob_gas),

        GasCosts.BLOB_BASE_FEE_UPDATE_FRACTION,

    )

    """

    Calculate the blob data fee for a transaction.

    Parameters

    ----------

    excess_blob_gas :

        The excess_blob_gas for the execution.

    tx :

        The transaction for which the blob data fee is to be calculated.

    Returns

    -------

    data_fee: `Uint`

        The blob data fee.

    """

    return Uint(calculate_total_blob_gas(tx)) * calculate_blob_gas_price(

        excess_blob_gas

    )