#include <bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;
using lint=long long;

template<class T> struct edge{
	int to;
	T wt;
	edge(int to,const T& wt):to(to),wt(wt){}
};
template<class T> using weighted_graph=vector<vector<edge<T>>>;

template<class T>
void add_directed_edge(weighted_graph<T>& G,int u,int v,const T& wt){
	G[u].emplace_back(v,wt);
}

template<class T>
pair<vector<T>,bool> Bellman_Ford(const weighted_graph<T>& G,int s){
	const T INF=numeric_limits<T>::max();

	int n=G.size();
	vector<T> d(n,INF);
	d[s]=0;
//	rep(_,n-1){
	rep(_,n){
		bool upd=false;
		rep(u,n) if(d[u]<INF) for(const auto& e:G[u]) {
			int v=e.to;
			if(d[v]>d[u]+e.wt) d[v]=d[u]+e.wt, upd=true;
		}
		if(!upd) return {d,true};
		if(_==n-1 && upd) return {d,false};
	}

	queue<int> Q;
	rep(u,n) if(d[u]<INF) Q.emplace(u);
	while(!Q.empty()){
		int u=Q.front(); Q.pop();
		for(const auto& e:G[u]){
			int v=e.to;
			if(d[v]>-INF && (d[u]==-INF || d[v]>d[u]+e.wt)) d[v]=-INF, Q.emplace(v);
		}
	}
	return {d,true};
}

/*
template<class T>
bool find_negative_cycle(const weighted_graph<T>& G){
	int n=G.size();
	vector<T> d(n);
	rep(t,n){
		bool relaxed=false;
		rep(u,n) for(const auto& e:G[u]) {
			if(d[e.to]<d[u]+e.wt){
				d[e.to]=d[u]+e.wt;
				relaxed=true;
				if(t==n-1) return true;
			}
		}
		if(!relaxed) break;
	}
	return false;
}
*/

int main(){
	int n,m; scanf("%d%d",&n,&m);
	vector<lint> w(n),l(m),v(m);
	rep(i,n) scanf("%lld",&w[i]);
	rep(j,m) scanf("%lld%lld",&l[j],&v[j]);

	if(*max_element(w.begin(),w.end())>*min_element(v.begin(),v.end())){
		puts("-1");
		return 0;
	}

	{
		vector<int> p(m);
		iota(p.begin(),p.end(),0);
		sort(p.begin(),p.end(),[&](int i,int j){
			return make_pair(v[i],-l[i])<make_pair(v[j],-l[j]);
		});

		vector<lint> v2,l2;
		rep(j,m){
			if(v2.empty() || l2.back()<l[p[j]]){
				v2.emplace_back(v[p[j]]);
				l2.emplace_back(l[p[j]]);
			}
		}
		v=v2;
		l=l2;
		m=v.size();
	}

	lint lo=-1,hi=1e9;
	while(hi-lo>1){
		lint mi=(lo+hi)/2;

		bool ok=false;
		vector<int> p(n);
		iota(p.begin(),p.end(),0);
		do{
			vector<lint> wsum(n+1);
			rep(i,n) wsum[i+1]=wsum[i]+w[p[i]];

			weighted_graph<lint> G(n);
			add_directed_edge(G,0,n-1,mi);
			rep(i,n-1){
				add_directed_edge(G,i+1,i,0LL);
			}
			rep(i,n) for(int j=i+1;j<n;j++) {
				int idx=lower_bound(v.begin(),v.end(),wsum[j+1]-wsum[i])-v.begin()-1;
				if(idx>=0){
					add_directed_edge(G,j,i,-l[idx]);
				}
			}

			if(Bellman_Ford(G,0).second){
				ok=true;
				break;
			}
		}while(next_permutation(p.begin(),p.end()));

		if(ok) hi=mi;
		else   lo=mi;
	}
	printf("%lld\n",hi);

	return 0;
}

#include <bits/stdc++.h>
#pragma GCC optimize(2)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<cstring>
#include<bitset>
#include<stack>
#include<time.h>



#define X first
#define Y second
#define PB push_back
#define MP make_pair
#define scd(a) scanf("%d",&a)
#define scdd(a,b) scanf("%d%d",&a,&b)
#define scddd(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define ALL(x) x.begin(),x.end()
#define sz(a) ((int)a.size())
#define getmid ((l+r)>>1)
#define mst(var,val) memset(var,val,sizeof(var))
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define lowbit(x) x&(-x)
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
#ifdef local
#define dbg(args...) cout << #args << " -> ", err(args);
void err(){ cout << endl; }
template<typename T, typename... Args>
void err(T a, Args... args){ cout << a << ' '; err(args...); }
#else
#define dbg(args...)
#endif // local

typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <int, ll> pil;
typedef pair <double, double> pdd;
const int inf=0x3f3f3f3f;
const long long INF=0x3f3f3f3f3f3f3f3fLL;
const double PI=acos(-1.0);
const long double eps=1e-8;
const int mod=1e9+7;
const int maxn=2e5+100;
const int N=2e5+100;
const int M=(1<<20)+10;
const ll mm=(1LL<<32);

template <class T>
inline void read(T &x)
{
    x = 0;
    char c = getchar();
    bool f = 0;
    for (; !isdigit(c); c = getchar())
        f ^= c == '-';
    for (; isdigit(c); c = getchar())
        x = x * 10 + (c ^ 48);
    x = f ? -x : x;
}

template <class T>
inline void write(T x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    T y = 1;
    int len = 1;
    for (; y <= x / 10; y *= 10)
        ++len;
    for (; len; --len, x %= y, y /= 10)
        putchar(x / y + 48);
}
ll qpow(ll a,ll b,ll mod)
{
    ll ans=1;
    while(b)
    {
        if(b&1)
            ans=(ans*a)%mod;
        b>>=1;
        a=(a*a)%mod;
    }
    return ans;
}


int main()
{
#ifdef local
    freopen("in.txt","r",stdin);
#endif // local
    IOS;cout.tie(0);
    int n,m;cin>>n>>m;
    if(m==0)
    {
        int tag=1;
        for(int i=1;i<=n;++i)
        {
            cout<<tag<<" "<<tag+1<<"\n";
            tag+=2;
        }
        return 0;
    }
    if(m<0||(m>n-2)){
        cout<<-1<<"\n";return 0;
    }
        int mx=2+2*m+2;
        cout<<1<<" "<<mx<<"\n";
        int tag=2;
        for(int i=1;i<=m+1;++i)
        {
            cout<<tag<<" "<<tag+1<<"\n";tag+=2;
        }
        mx++;
        for(int i=1;i<=n-m-2;++i){
            cout<<mx<<" "<<mx+1<<"\n";mx+=2;
        }

    return 0;
}

