import com.sun.org.apache.xpath.internal.operations.Bool
import java.lang.Math.*

const val MOD = 1000000007L

fun main(args: Array<String>) {

//    val hoge = divSearch(arrayListOf(0L, 2L, 5L, 8L, 14L, 21L, 22L, 24L, 25L, 27L).toLongArray(), 11L)
//    print(hoge)

    val (n, m) = readLongList()
    val a = readLongList().toLongArray().apply {
        sort()
    }

    val bc = Array<Pair<Long, Long>>(m.toInt()) {
        return@Array Pair(0L, 0L)
    }


    m.rep {
        val (b0, c0) = readLongList()
        bc[it.toInt()] = Pair(b0, c0)
    }

    bc.sortByDescending { it.second }


    var aIndex = 0
    var ans = 0L
    bc.forEach {
        if (aIndex == a.size) return@forEach
        val enableNum = it.first
        val replaceVal = it.second

        val next = min(aIndex + enableNum.toInt(), a.size)
        if (a[next - 1] <= replaceVal) {
            ans += replaceVal * (next - aIndex)
            aIndex = next
        } else {
            val bound = binarySearch(a.toTypedArray(), replaceVal, aIndex, next)
            ans += replaceVal * (bound - aIndex)
            a.forEachIndexed { index, l ->
                if (bound <= index) {
                    ans += l
                }
            }
            aIndex = a.size
        }
    }
    if (aIndex < a.size) {
        a.forEachIndexed { index, l ->
            if (index >= aIndex) {
                ans += l
            }
        }
    }
    print(ans)
}


fun readList() = readLine()!!.split(' ')
fun readInt() = readLine()!!.split(' ').map(String::toInt).first()
fun readIntList() = readList().map(String::toInt)
fun readLongList() = readList().map(String::toLong)
fun readDoubleList() = readList().map(String::toDouble)

fun readPair(): Pair<String, String> {
    val splite = readLine()!!.split(' ')
    return Pair(splite[0], splite[1])
}

fun <T> List<T>.copy() = this.map { it }

// 速度のためforEachは避ける
inline fun Int.rep(start: Int = 0, shiftLast: Boolean = false, body: (Int) -> Unit) {
    for (i in start until if (shiftLast) this + start else this) {
        body(i)
    }
}

inline fun Long.rep(start: Long = 0, shiftLast: Boolean = false, body: (Long) -> Unit) {
    for (i in start until if (shiftLast) this + start else this) {
        body(i)
    }
}

// 約数のList
fun divisor(value: Long): List<Long> {
    val max = sqrt(value.toDouble()).toLong()
    val former = mutableListOf<Long>()
    val latter = mutableListOf<Long>()
    (1..max).filter { value % it == 0L }
        .forEach {
            former.add(it)
            latter.add(value / it)
        }
    former.addAll(latter.reversed())
    return former
}

// 範囲内の素数を取得
// fromだけ指定すると戻り値の個数で素数判定ができる
fun prime(from: Long, to: Long = from): List<Long> {
    return (from..to).filter { i ->
        val max = Math.sqrt(i.toDouble()).toLong()
        (2..max).all { j -> i % j != 0L }
    }
}

// 素因数分解
fun decom(value: Long): List<Long> {
    if (value == 1L) return listOf(1)
    val max = Math.sqrt(value.toDouble()).toLong()
    return prime(2, max).filter { value % it == 0L }
}

// 最大公約数
fun gcd(a: Long, b: Long): Long {
    return if (a % b == 0L) b else gcd(b, a % b)
}

// 文字列を入れ替え
fun swap(base: String, a: String, b: String): String {
    return base.map {
        when (it) {
            a.toCharArray()[0] -> b
            b.toCharArray()[0] -> a
            else -> it.toString()
        }
    }.joinToString()
}

// 二分探索
fun binarySearch(array: Array<Long>, target: Long, _start: Int = 0, _end: Int = array.size): Int {
    var start = (_start - 1).toLong()
    var end = _end.toLong()
    while (end - start > 1) {
        val mid = (start + end) / 2
        if (array[mid.toInt()] < target) {
            start = mid
        } else {
            end = mid
        }
    }
    return end.toInt()
}

Measured memory_bytes: 101836