#include<bits/stdc++.h>
#define rep(i,a,...) for(int i = (a)*(strlen(#__VA_ARGS__)!=0);i<(int)(strlen(#__VA_ARGS__)?__VA_ARGS__:(a));++i)
#define per(i,a,...) for(int i = (strlen(#__VA_ARGS__)?__VA_ARGS__:(a))-1;i>=(int)(strlen(#__VA_ARGS__)?(a):0);--i)
#define foreach(i, n) for(auto &i:(n))
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
#define lambda(RES_TYPE, ...) (function<RES_TYPE(__VA_ARGS__)>)[&](__VA_ARGS__) -> RES_TYPE
#define method(FUNC_NAME, RES_TYPE, ...) function<RES_TYPE(__VA_ARGS__)> FUNC_NAME = lambda(RES_TYPE, __VA_ARGS__)
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
//const ll MOD = (ll)1e9+7;
const ll MOD = 998244353;
const int INF = (ll)1e9+7;
const ll INFLL = (ll)1e18;
template<class t>
using vvector = vector<vector<t>>;
template<class t>
using vvvector = vector<vector<vector<t>>>;
template<class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template<class t, class u> bool chmax(t &a, u b){if(a<b){a=b;return true;}return false;}
template<class t, class u> bool chmin(t &a, u b){if(a>b){a=b;return true;}return false;}
#ifdef DEBUG
#define debug(x) cout<<"LINE "<<__LINE__<<": "<<#x<<" = "<<x<<endl;
#else
#define debug(x) (void)0
#endif

namespace templates{
  ll modpow(ll x, ll b){
    ll res = 1;
    while(b){
      if(b&1)res = res * x % MOD;
      x = x * x % MOD;
      b>>=1;
    }
    return res;
  }

  ll modinv(ll x){
    return modpow(x, MOD-2);
  }

  bool was_output = false;
  template<class t>
  void output(t a){
    if(was_output)cout << " ";
    cout << a;
    was_output = true;
  }
  void outendl(){
    was_output = false;
    cout << endl;
  }
  ll in(){
    ll res;
    scanf("%lld", &res);
    return res;
  }

  template<class t>
  istream& operator>>(istream&is, vector<t>&x){
    for(auto &i:x)is >> i;
    return is;
  }

  template<class t, class u>
  istream& operator>>(istream&is, pair<t, u>&x){
    is >> x.first >> x.second;
    return is;
  }

  template<class t>
  t in(){
    t res; cin >> res; return res;
  }

  template<class t>
  void out(t x){
    cout << x;
  }

  template<class t>
  vector<t> sorted(vector<t> line,function<bool(t,t)> comp=[](t a,t b){return a<b;}){
    sort(line.begin(),line.end(),comp);
    return line;
  }

  template<class t>
  vector<t> reversed(vector<t> line){
    reverse(line.begin(),line.end());
    return line;
  }
}

using namespace templates;

ll func(){
    int n = in();
    int m = in();
    vector<int> weights(n);
    foreach(i,weights)i=in();
    sort(all(weights));

    vector<pll> bridge(m);
    foreach(i,bridge)i=in<pll>();

    ll res = INFLL;

    foreach(i,weights){
        foreach(bri,bridge){
            if(i > bri.second){
                return -1;
            }
        }
    }

    vector<ll> mins(bit(n));
    rep(i,bit(n)){
        ll sum = 0;
        rep(j,n){
            if(bit(j) & i){
                sum += weights[j];
            }
        }
        ll min_dis = 0;
        foreach(bri,bridge){
            if(sum > bri.second)chmax(min_dis,bri.first);
        }
        mins[i] = min_dis;
    }


    vector<int> order;
    rep(i,n)order.emplace_back(i);
    do{
        vector<ll> pos(n);
        rep(i,n){
            ll min_pos = 0;
            ll sum = bit(order[i]);
            per(j,i){
                sum += bit(order[j]);
                chmax(min_pos,mins[sum]+pos[j]);
            }
            pos[i] = min_pos;
        }
        chmin(res,pos.back());
    }while(next_permutation(all(order)));


    if(res==INFLL)return -1;
    return res;
}

int main(){
    cout << func() << endl;
  return 0;
}


using namespace std;

#define visual

#ifdef visual
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#include <assert.h>
#include <functional>
#include <math.h>
#include <string>
#include <ctime>
#endif
#ifndef visual
#include <bits/stdc++.h>
#endif

typedef long long ll;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

    long long n, m;
    cin >> n >> m;

    vector<long long> w;
    long long mxw = 0;
    for (long long i = 0; i < n; i++) {
        long long x;
        cin >> x;

        mxw = max(mxw, x);
        w.push_back(x);
    }

    vector<pair<long long, long long>> v;
    v.push_back({ 0, 0 });
    for (long long i = 0; i < m; i++) {
        long long x, y;
        cin >> x >> y;
        if (y < mxw) {
            cout << -1 << endl;
            return 0;
        }
        v.push_back({y, x});
        //camels with weight more than first must have length at least second
    }
    sort(v.begin(), v.end());
    vector<pair<long long, long long> > u;
    long long cur = -1;
    for (long long i = 0; i < v.size(); i++) {
        
        if (v[i].second > cur) {
            u.push_back(v[i]);
            //cout << v[i].first << " " << v[i].second << endl;
            cur = v[i].second;
        }
    } //u now has increasing firsts, increasing seconds

    sort(w.begin(), w.end());

    ll ans = -1;
    do {
        vector<long long> loc(n);
        for (long long i = 0; i < n; i++) {
            long long bst = 0;
            
            for (long long j = 0; j < i; j++) {
                long long a;
                long long tot = 0;
                for (long long k = j; k <= i; k++) {
                    tot += w[k];
                }
                pair<long long, long long> p = { tot, -1 };
                auto i = lower_bound(u.begin(), u.end(), p);
                i--;
                a = (*i).second;
                //a should be minimum distance for weight of tot
                bst = max(bst, loc[j] + a);
            }
            loc[i] = bst;
        }
        //cout << loc[n-1] << endl;
        if (ans == -1 || loc[n-1] < ans) {
            ans = loc[n-1];
        }
    } while (next_permutation(w.begin(), w.end()));

    cout << ans << endl;



}
