using System;
using System.Collections.Generic;
using System.Text;
using System.Numerics;
using System.IO;


namespace SolutionCS
{
    class Program
    {
        public class TestElem : IComparable
        {
            public int value;
            public int num;

            public TestElem(int v, int n)
            {
                value = v;
                num = n;
            }

            public int CompareTo(object obj)
            {
                TestElem other = (TestElem)obj;

                return -value.CompareTo(other.value);
            }
        }

        public class PriorityQueue<T> where T : IComparable
        {
            T[] heap;
            int count = 0;

            public PriorityQueue(int maxSize)
            {
                heap = new T[maxSize];
                count = 0;
            }

            public void Push(T elem)
            {
                // 要素をPushするインデックス(枝の末尾部分)
                int i = count;

                // 要素数を増やす
                count++;

                // 親(i=0)に向かってたどる
                while (i > 0)
                {
                    // 親のインデックス
                    int p = (i - 1) / 2;

                    // elemのほうが大きいか同一の場合、Pushするインデックス確定
                    if (heap[p].CompareTo(elem) <= 0)
                    {
                        break;
                    }

                    // 親→子にコピーして再度親との比較を行う
                    heap[i] = heap[p];
                    i = p;
                }

                // 要素を決まったインデックスに入れる
                heap[i] = elem;
            }

            public T Pop()
            {
                // 要素なしの場合、Exception
                if (count == 0)
                {
                    throw new InvalidOperationException();
                }

                // 要素数減らす
                count--;

                // 返す要素を保存
                T result = heap[0];

                // 一番末端の要素(これを親から比較して配列に配置する)
                T x = heap[count];

                // 親から末尾に向かって子→親入れ替えを行う
                int i = 0;
                while (i * 2 + 1 < count)
                {
                    int l = i * 2 + 1;      // 子の左枝のインデックス
                    int r = i * 2 + 2;      // 子の右枝のインデックス

                    // 右が範囲外ではない、右のほうが小さいか検証
                    if (r < count && heap[r].CompareTo(heap[l]) < 0)
                    {
                        // 右のほうが小さい場合、上に上がっていくのは右のインデックス
                        l = r;
                    }

                    // x(配列の一番最後の要素)と比べて、大きければおわり
                    if (heap[l].CompareTo(x) >= 0)
                    {
                        break;
                    }

                    // 一個親側に繰り上げ
                    heap[i] = heap[l];

                    // 処理した枝のインデックスを与え、再度入れ替え
                    i = l;
                }

                // 一番末尾の要素を新たに保存
                heap[i] = x;

                // 最初に保存していた結果を返す
                return result;
            }

            public int Count { get { return count; } }
            public T Peek { get { return heap[0]; } }
        }

        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split(' ');
            int N = int.Parse(s[0]);
            int M = int.Parse(s[1]);

            PriorityQueue<TestElem> pq = new PriorityQueue<TestElem>(N + M);

            s = Console.ReadLine().Split(' ');
            for (int i = 0; i < N; i++)
            {
                TestElem e = new TestElem(int.Parse(s[i]), 1);
                pq.Push(e);
            }

            for (int i = 0; i < M; i++)
            {
                s = Console.ReadLine().Split(' ');

                TestElem e = new TestElem(int.Parse(s[1]), int.Parse(s[0]));
                pq.Push(e);
            }

            int count = 0;
            long ans = 0;
            while (pq.Count > 0 &&  count < N)
            {
                TestElem e = pq.Pop();

                int taken = e.num;
                if (count + taken > N )
                {
                    taken = N - count;
                }

                count += taken;

                ans += Math.BigMul(e.value, taken);
            }


            Console.WriteLine(ans);
        }
    }
}


Measured memory_bytes: 31832