#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define MP make_pair
#define PB push_back
#define FF first
#define SS second

typedef long long ll;
const int mod = 998244353;
const int maxsize = 2222;
const int proot = 3;
const int maxn = 2222;

ll qpow(ll x, ll y) {
	ll ret = 1;
	while(y) {
		if(y&1) ret = ret * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return ret;
}

struct ntt {
	int n, M, w_pre[maxsize], inv[maxsize];
	ntt() {
		M = 1;
		while(M*2<maxsize) M <<= 1;
		int w = qpow(proot, (mod - 1) / M);
		w_pre[0] = 1;
		for(int i=1; i<=M; i++) w_pre[i] = 1ll * w_pre[i-1] * w % mod;
		inv[1] = 1;
		for(int i=2; i<maxsize; i++) inv[i] = mod - 1ll * inv[mod % i] * (mod / i) % mod;
	}
	void FFTinit(int sz) {
		n = 1;
		while(n < sz) n <<= 1;
		if (n > M) cout<<n<<endl;
		assert(n <= M);
	}
	void FFT(int a[], int coef) {
		typedef unsigned long long ull;
		const ull mod2 = 1ull * mod * mod;
		static ull na[maxsize];
		for(int i=0, j=0; i<n; i++) {
			na[j] = a[i] < 0 ? (a[i] + mod) : a[i];
			for(int l=n>>1; (j^=l) < l; l>>=1) continue;
		}
		static int w[maxsize];
		for(int l=1; l<n; l<<=1) {
			int l2 = l + l, u = M / l2;
			if(coef == 1) {
				for(int j=0, t=0; j<l; j++, t+=u) w[j] = w_pre[t];
			}
			else {
				for(int j=0, t=M; j<l; j++, t-=u) w[j] = w_pre[t];
			}
			for(int i=0; i<n; i+=l2) {
				for(int j=0; j<l; j++) {
					ull tmp = na[i+j+l] % mod * w[j];
					na[i+j+l] = na[i+j] - tmp + mod2;
					na[i+j] += tmp;
				}
			}
			if(l == (1 << 8) || l == (1 << 16)) for(int i=0; i<n; i++) na[i] %= mod;
		}
		for(int i=0; i<n; i++) a[i] = 1ll * na[i] % mod * (coef == -1?inv[n]:1) % mod;
	}
	vector<int> multi(vector<int> &A, vector<int> &B, int N = -1) {
		if(N == -1) N = max(0, int(A.size() + B.size()) - 1);
		FFTinit(A.size() + B.size());
		static int a[maxsize], b[maxsize];
		for(int i=0; i<n; i++) a[i] = i < A.size() ? A[i] % mod : 0;
		for(int i=0; i<n; i++) b[i] = i < B.size() ? B[i] % mod : 0;
		FFT(a, 1);
		FFT(b, 1);
		for(int i=0; i<n; i++) a[i] = 1ll * a[i] * b[i] % mod;
		FFT(a, -1);
		vector<int> ret(N);
		for(int i=0; i<N; i++) ret[i] = a[i];
		return ret;
	}
} M1;

namespace MUL {
	int a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];
	int sz;
	void FFT(int a[maxn][maxn], int coef) {
		if (coef==1) {
			for (int i=0; i<sz; i++) {
				M1.FFT(a[i], 1);
			}
			for (int i=0; i<sz; i++) {
				for (int j=0; j<sz; j++) {
					if (i<j) {
						swap(a[i][j], a[j][i]);
					}
				}
			}
			for (int i=0; i<sz; i++) {
				M1.FFT(a[i], 1);
			}
			for (int i=0; i<sz; i++) {
				for (int j=0; j<sz; j++) {
					if (i<j) {
						swap(a[i][j], a[j][i]);
					}
				}
			}
		} else {
			for (int i=0; i<sz; i++) {
				for (int j=0; j<sz; j++) {
					if (i<j) {
						swap(a[i][j], a[j][i]);
					}
				}
			}
			for (int i=0; i<sz; i++) {
				M1.FFT(a[i], -1);
			}
			for (int i=0; i<sz; i++) {
				for (int j=0; j<sz; j++) {
					if (i<j) {
						swap(a[i][j], a[j][i]);
					}
				}
			}
			for (int i=0; i<sz; i++) {
				M1.FFT(a[i], -1);
			}
		}
	}
	void mul(int an, int am, int bn, int bm) {
		int _sz = max(an + bn, am + bm) + 1;
		M1.FFTinit(_sz);
		sz = M1.n;

		for (int i=0; i<sz; i++) for (int j=0; j<sz; j++) {
			a[i][j] = i < an && j < am ? a[i][j] % mod : 0;
			b[i][j] = i < bn && j < bm ? b[i][j] % mod : 0;
		}
		FFT(a, 1);
		FFT(b, 1);
		for (int i=0; i<sz; i++) for (int j=0; j<sz; j++) {
			c[i][j] = 1ll * a[i][j] * b[i][j] % mod;
		}
		FFT(c, -1);
	}
}

int fac[maxn], invf[maxn];


int n, m;
int d[maxn];
int f[maxn][maxn], g[maxn][maxn], dp[maxn];
vector<pair<int,int> > pt;
void upd(int &x, int v) {
	x = (x+v)%mod;
}
int a[maxn][maxn];
void cont(int xl, int xr, int yl, int yr, int XL, int XR, int YL, int YR) {
	for (int i=xl; i<=xr; i++) for (int j=yl; j<=yr; j++) {
		MUL::a[i-xl][j-yl] = f[i][j];
	}
	for (int i=0; i<=XR-XL; i++) for (int j=0; j<=YR-YL; j++) {
		MUL::b[i][j] = g[i][j];
	}
	MUL::mul(xr-xl+1, yr-yl+1, XR-XL+1, YR-YL+1);

	for (int i=XL; i<=XR; i++) for (int j=YL; j<=YR; j++) {
		if (i>=xl && i<=xr && j>=yl && j<=yr) continue;
		if (i>=xl && j>=yl) upd(a[i][j], MUL::c[i-xl][j-yl]);
	}
}
void solve(int xl, int xr, int yl, int yr) {
	if (xl==xr) {
		f[xl][yl] = a[xl][yl] + (xl==0 && yl==0);
		return;
	}
	int xm = xl + xr >> 1;
	int ym = yl + yr >> 1;
	
	solve(xl, xm, yl, ym);
	cont(xl, xm, yl, ym, xl, xr, yl, yr);

	solve(xm+1, xr, yl, ym);
	cont(xm+1, xr, yl, ym, xl, xr, yl, yr);
	
	solve(xl, xm, ym+1, yr);
	cont(xl, xm, ym+1, yr, xl, xr, yl, yr);

	solve(xm+1, xr, ym+1, yr);
}
void calc_f() {
	// f[0][0] = 1;
	// for (int i=0; i<=1000; i++) for (int j=0; j<=1000; j++) {
	// 	for (int x=0; x<=10; x++) for (int y=0; y<=10; y++) {
	// 		upd(f[i+x][j+y], 1ll * f[i][j] * g[x][y] % mod);
	// 	}
	// }
	solve(0, 1023, 0, 1023);
}

int getf(pair<int,int> x, pair<int,int> y) {
	int i = y.FF - x.FF;
	int j = y.SS - x.SS;
	if (i < 0 || j < 0) return 0;
	return f[i][j];
}
int main() {
	// MUL::a[0][1] = 1;
	// MUL::a[1][0] = 2;
	// MUL::b[0][0] = 3;
	// MUL::b[1][1] = 4;
	// MUL::mul(2, 2, 2, 2);
	// for (int i=0; i<4; i++) {
	// 	for (int j=0; j<4; j++) {
	// 		cout<<MUL::c[i][j]<<" ";
	// 	}cout<<endl;
	// }
	
	fac[0] = 1;
	for(int i=1; i<maxn; i++) fac[i] = 1ll * i * fac[i-1] % mod;
	invf[maxn-1] = qpow(fac[maxn-1], mod - 2);
	for(int i=maxn-1; i>=1; i--) invf[i-1] = 1ll * i * invf[i] % mod;
	
	scanf("%d%d", &n, &m);
	for (int i=1; i<=n; i++) {
		scanf("%d", &d[i]);
	}
	for (int i=1; i<=m; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		pt.PB(MP(x, y));
	}
	pt.PB(MP(0, 0));

	for (int i=1; i<=n; i++) {
		for (int j=0; j<=d[i]; j++) {
			int tsqr = d[i] * d[i] - j * j;
			int tmp = sqrt(tsqr);
			while ((tmp+1)*(tmp+1) <= tsqr) tmp++;
			g[j][tmp] ++;
		}
	}
	for (int i=0; i<=1000; i++) {
		for (int j=1000; j>0; j--) {
			g[i][j-1] = (g[i][j-1] + g[i][j]) % mod;
		}
	}
	g[0][0] = 0;

	calc_f();
	// for (int i=0; i<10; i++) {
	// 	for (int j=0; j<10; j++) {
	// 		cout<<f[i][j]<<" ";
	// 	}cout<<endl;
	// }

	sort(pt.begin(), pt.end());
	reverse(pt.begin(), pt.end());

	for (int i=0; i<pt.size(); i++) {
		dp[i] = getf(pt[i], MP(1000, 1000));
		for (int j=0; j<i; j++) {
			dp[i] = (dp[i] - 1ll * dp[j] * getf(pt[i], pt[j])) % mod;
		}
	}
	cout<<(dp[pt.size()-1] + mod) % mod<<endl;
	return 0;
}