"""

    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:

        raise OutOfGasError

    """

    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 stipend) 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 CREAT*

    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 GAS_INIT_CODE_WORD_COST * ceil32(init_code_length) // Uint(32)