"""
カードの中から値がC未満のものをB枚までCに変更していく。これを高速に行えばよい。
heapqにぶち込めばよさそう?いや、それだとO(NMlogN)かかる
BIT使えばよいのか？いや、それもダメO(10**9log10**9)かかる
1クエリに対して、logN以下で処理しなくてはいけない。
Aを昇順に並べ替えておいて、常に昇順が保たれるようにしておけば二分探索できる。
あーでも途中で値を更新する作業があるから結局O(MN)かかるな
そもそも値を配列で管理してはいけないんだな。
どの値がいくつある。という管理の仕方をしないといけない。
ってなると、座標圧縮してBITだな。これはムズイわ。
"""
class BIT:
    def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

    def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
    def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i

import heapq
N,M = map(int,input().split())
A = list(map(int,input().split()))
heapq.heapify(A)
BC = [list(map(int,input().split())) for _ in range(M)]
BC.sort(key=lambda x: -x[1])

for b,c in BC:
    while b > 0:
        b -= 1
        a = heapq.heappop(A)
        if a < c:
            heapq.heappush(A,c)
        else:
            heapq.heappush(A,a)
            break
    else:
        continue
    break
print(sum(A)) """
カードの中から値がC未満のものをB枚までCに変更していく。これを高速に行えばよい。
heapqにぶち込めばよさそう?いや、それだとO(NMlogN)かかる
BIT使えばよいのか？いや、それもダメO(10**9log10**9)かかる
1クエリに対して、logN以下で処理しなくてはいけない。
Aを昇順に並べ替えておいて、常に昇順が保たれるようにしておけば二分探索できる。
あーでも途中で値を更新する作業があるから結局O(MN)かかるな
そもそも値を配列で管理してはいけないんだな。
どの値がいくつある。という管理の仕方をしないといけない。
ってなると、座標圧縮してBITだな。これはムズイわ。
""" class BIT:
    def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

    def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
    def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i BIT def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

     __init__ self.tree = [0]*(n+1) self.tree self tree [0]*(n+1) [0] 0 n+1 n 1 self.size = n self.size self size n self self n n def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
     sum s = 0 s 0 while i > 0:
            s += self.tree[i]
            i -= i&-i
    
     i > 0 i 0 s += self.tree[i] s self.tree[i] self.tree self tree i i -= i&-i i i&-i i -i i self self i i def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i add while i <= self.size:
            self.tree[i] += x
            i += i&-i i <= self.size i self.size self size self.tree[i] += x self.tree[i] self.tree self tree i x i += i&-i i i&-i i -i i self self i i x x import heapq heapq N,M = map(int,input().split()) N map(int,input().split()) map int input().split() ().split () input split M A = list(map(int,input().split())) A list(map(int,input().split())) list map(int,input().split()) map int input().split() ().split () input split heapq.heapify(A) heapq.heapify heapq heapify A list(map(int,input().split())) for _ in range(M) for _ in range(M) _ range(M) range M for _ in range(M) list(map(int,input().split())) list map(int,input().split()) map int input().split() ().split () input split BC = [list(map(int,input().split())) for _ in range(M)] BC [list(map(int,input().split())) for _ in range(M)] BC.sort(key=lambda x: -x[1]) BC.sort BC sort key=lambda x: -x[1] key lambda x: -x[1] -x[1] x[1] x 1 x for b,c in BC:
    while b > 0:
        b -= 1
        a = heapq.heappop(A)
        if a < c:
            heapq.heappush(A,c)
        else:
            heapq.heappush(A,a)
            break
    else:
        continue
    break b c BC while b > 0:
        b -= 1
        a = heapq.heappop(A)
        if a < c:
            heapq.heappush(A,c)
        else:
            heapq.heappush(A,a)
            break
    else:
        continue
     b > 0 b 0 b -= 1 b 1 a = heapq.heappop(A) a heapq.heappop(A) heapq.heappop heapq heappop A if a < c:
            heapq.heappush(A,c)
        else:
            heapq.heappush(A,a)
            break
     a < c a c heapq.heappush(A,c) heapq.heappush heapq heappush A c heapq.heappush(A,a) heapq.heappush heapq heappush A a break continue break print(sum(A)) print sum(A) sum A class BIT:
    def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

    def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
    def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i class BIT:
    def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

    def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
    def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i BIT BC = [list(map(int,input().split())) for _ in range(M)] [list(map(int,input().split())) for _ in range(M)] BC a = heapq.heappop(A) heapq.heappop(A) a A = list(map(int,input().split())) list(map(int,input().split())) A M = map(int,input().split()) map(int,input().split()) M b -= 1 1 b N,M = map(int,input().split()) map(int,input().split()) N
"""
カードの中から値がC未満のものをB枚までCに変更していく。これを高速に行えばよい。
heapqにぶち込めばよさそう?いや、それだとO(NMlogN)かかる
BIT使えばよいのか？いや、それもダメO(10**9log10**9)かかる
1クエリに対して、logN以下で処理しなくてはいけない。
Aを昇順に並べ替えておいて、常に昇順が保たれるようにしておけば二分探索できる。
あーでも途中で値を更新する作業があるから結局O(MN)かかるな
そもそも値を配列で管理してはいけないんだな。
どの値がいくつある。という管理の仕方をしないといけない。
ってなると、座標圧縮してBITだな。これはムズイわ。
"""
class BIT:
    def __init__(self,n):
        self.tree = [0]*(n+1)
        self.size = n

    def sum(self,i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i&-i
    
    def add(self,i,x):
        while i <= self.size:
            self.tree[i] += x
            i += i&-i

import heapq
N,M = map(int,input().split())
A = list(map(int,input().split()))
heapq.heapify(A)
BC = [list(map(int,input().split())) for _ in range(M)]
BC.sort(key=lambda x: -x[1])

for b,c in BC:
    while b > 0:
        b -= 1
        a = heapq.heappop(A)
        if a < c:
            heapq.heappush(A,c)
        else:
            heapq.heappush(A,a)
            break
    else:
        continue
    break
print(sum(A))
