"""

    Subtracts `amount` from `evm.gas_left`.

    Parameters

    ----------

    evm :

        The current EVM.

    amount :

        The amount of gas the current operation requires.

    """

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

    if evm.gas_left < amount:

        raise OutOfGasError

    else:

        evm.gas_left -= 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 * GAS_MEMORY

    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 = Uint(len(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))