#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T,class U> using P = pair<T,U>;
template<class T> using vec = vector<T>;
template<class T> using vvec = vector<vec<T>>;

constexpr ll mod = 1e9+7;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod){}
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        mint res(*this);
        return res+=a;
    }
    mint operator-(const mint a) const {
        mint res(*this);
        return res-=a;
    }
    mint operator*(const mint a) const {
        mint res(*this);
        return res*=a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }

    bool operator==(const mint& a)const{
        return x==a.x;
    }
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }
    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }
};

template<typename Monoid,typename OperatorMonoid,typename F,typename G,typename H>
class LazySegmentTree {
private:
	int sz,height;
	vec<Monoid> data;
	vec<OperatorMonoid> lazy;
	const F op;
	const G homo;
	const H comp;
  	const Monoid e;
	const OperatorMonoid Oe;
public:
	LazySegmentTree(int n,const F op,const G homo,const H comp,
					const Monoid &e,const OperatorMonoid Oe)
		: op(op),homo(homo),comp(comp),e(e),Oe(Oe) {
		sz = 1;
		height = 0;
		while(sz<=n) sz <<= 1,height++;
		data.assign(2*sz,e);
		lazy.assign(2*sz,Oe);
	}

	void set(int k,const Monoid &x) {
		data[k+sz] = x;
	}

	void build() {
		for(int k=sz-1;k>0;k--) {
			data[k] = op(data[2*k], data[2*k+1]);
		}
	}

	inline void propagate(int k) {
		if(lazy[k]!=Oe) {
			lazy[2*k] = comp(lazy[2*k], lazy[k]);
			lazy[2*k+1] = comp(lazy[2*k+1], lazy[k]);
			data[k] = reflect(k);
			lazy[k] = Oe;
		}
	}

	inline Monoid reflect(int k) {
		return lazy[k] == Oe? data[k]:homo(data[k],lazy[k]);
	}

	inline void recalc(int k) {
		while(k>>=1) data[k] = op(reflect(2*k), reflect(2*k+1));
	}

	inline void thrust(int k) {
		for(int i=height;i>0;i--) propagate(k>>i);
	}

	void update(int a, int b, const OperatorMonoid &x) {
		thrust(a+=sz);
		thrust(b+=sz-1);
		for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
			if(l&1) lazy[l] = comp(lazy[l],x),++l;
			if(r&1) --r, lazy[r] = comp(lazy[r],x);
		}
		recalc(a);
		recalc(b);
	}

	Monoid query(int a, int b) {
		thrust(a+=sz);
		thrust(b+=sz-1);
		Monoid L = e, R = e;
		for(int l=a, r=b+1;l<r;l>>= 1,r>>=1) {
			if(l&1) L = op(L,reflect(l++));
			if(r&1) R = op(reflect(--r),R);
		}
		return op(L,R);
	}

	Monoid operator[](const int &k) {
		return query(k,k+1);
	}
};

template <class T>
class Compress{
    map<T,int> idx;
    map<int,T> value;
    vector<T> cmp;
public:
    int N;
    Compress(vector<T> v){
        for(auto& x:v) cmp.push_back(x);
        sort(cmp.begin(),cmp.end());
        cmp.erase(unique(cmp.begin(),cmp.end()),cmp.end());
        N = cmp.size();
        for(int i=0;i<N;i++) idx[cmp[i]] = i;
    }
    int id(T val){return idx[val];}
    T val(int id){return cmp[id];}
};

struct robot{
    int l,r;
    bool operator<(const robot& R)const{
        if(l!=R.l) return l<R.l;
        return r<R.r;
    }
};

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N,M;
    const int inf = 2e9;
    cin >> N >> M;
    vec<int> X(N),Y(M+1,-inf);
    for(int i=0;i<N;i++) cin >> X[i];
    for(int i=1;i<=M;i++) cin >> Y[i];
    Y.push_back(inf);
    vec<robot> R(N);
    vec<int> v = {0};
    for(int i=0;i<N;i++){
        int id = lower_bound(Y.begin(),Y.end(),X[i])-Y.begin();
        int r = (Y[id]!=inf? Y[id]-X[i]:inf),l = (id!=1? X[i]-Y[id-1]:inf);
        R[i] = {l,r};
        if(r!=inf) v.push_back(r);
    }
    sort(R.begin(),R.end());
    Compress<int> cmp(v);
    int n = cmp.N;

    struct state{
        mint val;
        ll len;
    };
    auto op = [](state L,state R){return (state){L.val+R.val,L.len+R.len};};
    auto homo = [](state S,ll x){return (state){x*S.len,S.len};};
    auto comp = [](ll x,ll y){return (y!=-1? y:x);};
    LazySegmentTree<state,ll,decltype(op),decltype(homo),decltype(comp)>
    seg(n,op,homo,comp,(state){0,0},-1);
    for(int i=0;i<n;i++){
        seg.set(i,(state){i==0,1});
    }
    seg.build();
    for(int i=0;i<N;i++){
        if(R[i].r!=inf){
            int l = ((i==0 || R[i].l!=R[i-1].l)? 0:cmp.id(R[i-1].r));
            state add = seg.query(l,cmp.id(R[i].r));
            state res = seg.query(cmp.id(R[i].r),cmp.id(R[i].r)+1);
            ll x = (res.val+add.val).x;
            seg.update(cmp.id(R[i].r),cmp.id(R[i].r)+1,x);
        }
        if(R[i].l==inf) seg.update(0,cmp.id(R[i].r),0);
    }
    mint ans = 0;
    for(int i=0;i<n;i++) ans += seg[i].val;
    cout << ans.x << endl;
}

Measured memory_bytes: 13044