// Sea, You & Me
#include<bits/stdc++.h>
#define LL long long
#define DB double
#define MOD 1000000007
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define lowbit(x) ((-x) & x)
#define MP make_pair
#define MT make_tuple
#define VI vector<int>
#define VL vector<LL>
#define VII VI::iterator
#define VLI VL::iterator
#define all(x) x.begin(), x.end()
#define EB emplace_back
#define PII pair<int, int>
#define SI set<int>
#define SII SI::iterator
#define fi first
#define se second
using namespace std;
template<typename T> void chkmn(T &a, const T b) { (a > b) && (a = b); }
template<typename T> void chkmx(T &a, const T b) { (a < b) && (a = b); }
void Inc(int &a, const int &b) { ((a += b) >= MOD) && (a -= MOD); }
void Dec(int &a, const int &b) { ((a -= b) < 0) && (a += MOD); }
void Mul(int &a, const int &b) { a = 1LL * a * b % MOD; }
void Sqr(int &a) { a = 1LL * a * a % MOD; }
int inc(const int &a, const int &b) { return (a + b >= MOD) ? a + b - MOD : a + b; }
int dec(const int &a, const int &b) { return (a - b < 0) ? a - b + MOD : a - b; }
int mul(const int &a, const int &b) { return 1LL * a * b % MOD; }
int sqr(const int &a) { return 1LL * a * a % MOD; }
int qwqmi(int x, int k = MOD - 2)
{
	int res = 1;
	while(k)
	{
		if(k & 1) Mul(res, x);
		k >>= 1, Sqr(x);
	}
	return res;
}
template<typename T> void read(T &x)
{
	x = 0;
	int f = 1;
	char ch = getchar();
	while(!isdigit(ch))
	{
		if(ch == '-')
			f = -1;
		ch = getchar();
	}
	while(isdigit(ch))
	{
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x = x * f;
}
const int N = 2e5 + 5;
const int F = 21;
const int INF = 1e9 + 7;
int n, m, a[N], b[N];
struct ST
{
	int w[N][F];
	void build()
	{
		for(int i = 1; i <= n; ++i)
			w[i][0] = a[i];
		for(int j = 1; j < F; ++j)
			for(int i = 1; i + (1 << j) - 1 <= n; ++i)
				w[i][j] = min(w[i][j - 1], w[i + (1 << (j - 1))][j - 1]);	
	}	
	int query(int l, int r)
	{
		int j = log2(r - l + 1);
		return min(w[l][j], w[r - (1 << j) + 1][j]);
	}
}st;
int pmax[N], pmin[N]; 
int smax[N], smin[N];

struct SGT
{
	struct SegTree
	{
		int l, r;
		int sum, cnt;
	}tr[N << 2];
	void pushup(int p)
	{
		if(tr[p].cnt) tr[p].sum = tr[p].r - tr[p].l + 1;
		else tr[p].sum = tr[ls(p)].sum + tr[rs(p)].sum;
	}
	void build(int p, int l, int r)
	{
		tr[p].l = l;
		tr[p].r = r;
		if(l == r)
			return;
		int mid = l + (r - l) / 2;
		build(ls(p), l, mid);
		build(rs(p), mid + 1, r);
	}
	void modify(int p, int l, int r, int v)
	{
		if(tr[p].l >= l && tr[p].r <= r)
		{
			tr[p].cnt += v;
			pushup(p);
			return;
		}
		int mid = tr[p].l + (tr[p].r - tr[p].l) / 2;
		if(mid >= l) modify(ls(p), l, r, v);
		if(mid < r) modify(rs(p), l, r, v);
		pushup(p);
	}
}T;
struct Akashi
{
	int l, r, op;
};
vector<Akashi> vec[N];
void add(int xl, int yl, int xr, int yr)
{
//	cerr << xl << ' ' << yl << ' ' << xr << ' ' << yr << '\n';
	vec[xl].EB((Akashi){yl, yr, 1});
	vec[xr + 1].EB((Akashi){yl, yr, -1});
}
int main()
{
	read(n), read(m);
	for(int i = 1; i <= n; ++i)
		read(a[i]);
	for(int i = 1; i <= m; ++i)
		read(b[i]);
	st.build();
	pmin[1] = pmax[1] = b[1];
	for(int i = 2; i <= m; ++i)
	{
		pmin[i] = min(pmin[i - 1], b[i]);
		pmax[i] = max(pmax[i - 1], b[i]);
	}
	smin[m] = smax[m] = b[m];
	for(int i = m - 1; i >= 1; --i)
	{
		smin[i] = min(smin[i + 1], b[i]);
		smax[i] = max(smax[i + 1], b[i]);
	}
	
	// row
	for(int i = 1; i <= n; ++i)
		if(a[i] + pmax[m] < 0)
			add(1, i, i, n);
	
	// col
	{
		int l = 1, r = 1;
		while(l <= n && r <= n)
		{
			while(a[l] + pmin[m] >= 0) ++l;
			if(l > n) break;
			r = l;
			while(a[r] + pmin[m] < 0) ++r;
			add(l, l, r - 1, r - 1);
			l = r;
		}
	}
	
	// start
	for(int i = 1; i <= n; ++i)
	{
		int l = 1, r = m, y = 0;
		while(l <= r)
		{
			int mid = (l + r) / 2;
			if(pmax[mid] + a[i] < 0)
				y = mid, l = mid + 1;
			else r = mid - 1;
		}
		if(!y) continue;
		l = 1, r = i; int x = i;
		while(l <= r)
		{
			int mid = (l + r) / 2;
			if(pmin[y] + st.query(mid, i) < 0)
				x = mid, r = mid - 1;
			else l = mid + 1;
		}
		add(x, x, i, n);
	}
	
	// end
	for(int i = 1; i <= n; ++i)
	{
		int l = 1, r = m, y = m + 1;
		while(l <= r)
		{
			int mid = (l + r) / 2;
			if(smax[mid] + a[i] < 0)
				y = mid, r = mid - 1;
			else l = mid + 1;
		}
		if(y == m + 1) continue;
		l = i, r = n; int x = i;
		while(l <= r)
		{
			int mid = (l + r) / 2;
			if(smin[y] + st.query(i, mid) < 0)
				x = mid, l = mid + 1;
			else r = mid - 1;
		}
		add(1, i, x, x);
	}
	
	// s > t
	for(int i = 1; i <= n; ++i)
		add(i, 1, i, i - 1);
	
	// calculate ans
	T.build(1, 1, n);
	LL ans = 0;
	for(int i = 1; i <= n; ++i)
	{
		for(auto now : vec[i])
			T.modify(1, now.l, now.r, now.op);
		ans += n - T.tr[1].sum;
	}
	printf("%lld\n", ans);
	return 0;
}