#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<math.h>
#include<numeric>
#include<cassert>
#include<random>
#include<deque>
#include<chrono>
#include<unordered_map>
#include<list>
#include<fstream>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
const ll E=1e18+7;
#define F first
#define S second
#define MK make_pair
const ll MOD=1000000007;

template<typename T>
vector<T> press(vector<T> a,T start,T dist){
    vector<T> b=a;
    sort(b.begin(),b.end());
    T count=start;
    map<T,T> M;
    for(int i=0;i<b.size();i++){
        if(M.find(b[i])==M.end()){M[b[i]]=count; count+=dist;}
    }
    for(int i=0;i<a.size();i++){
        a[i]=M[a[i]];
    }
    return a;
}

vector<pll> press(vector<pll> a,ll start,ll dist){
    vector<ll> x,y;
    for(int i=0;i<a.size();i++){
        x.push_back(a[i].F);
        y.push_back(a[i].S);
    }
    x=press(x,start,dist);
    y=press(y,start,dist);
    for(int i=0;i<a.size();i++){
        a[i]={x[i],y[i]};
    }
    return a;
}


//0-index
template<typename T,typename U> //T::要素,U::作用素
class late_seg_tree{
private:
    typedef pair<T,U> node;
    vector<vector<node>> tree;
    ll high;
    T err_T;
    U err_U;
    ll err;
    
    T F(T,T); //要素のマージ (要素,要素)
    T G(T,U,ll); //作用素->要素 (要素,作用素,場所)
    U H(U,U); //作用素のマージ (作用素,作用素)
    T I(T,U,ll,ll); //作用素->区間要素 (要素,作用素,l,r) [l,r)
    
    ll bit_size(ll a){
        for(int i=1;i<63;i++){
            if(1<<i >= a){return i;}
        }
        return err;
    }
    
    //[l,r)
    void update(ll h,ll where,ll l,ll r,U u){
        ll L=where<<(high-h-1);
        ll R=(where+1)<<(high-h-1);
        if(r<=L || R<=l){return;}
        if(h==high-1){tree[h][where].F=G(tree[h][where].F,u,where); return;}
        if(l<=L && R<=r){
            tree[h][where].S=H(tree[h][where].S,u);
            tree[h][where].F=F(tree[h+1][where*2].F,tree[h+1][where*2+1].F);
            tree[h][where].F=I(tree[h][where].F,tree[h][where].S,L,R);
        }
        else{
            update(h+1,where*2,l,r,u);
            update(h+1,where*2+1,l,r,u);
            tree[h][where].F=F(tree[h+1][where*2].F,tree[h+1][where*2+1].F);
            tree[h][where].F=I(tree[h][where].F,tree[h][where].S,L,R);
        }
    }
    
    T search(ll h,ll where,ll l,ll r){
        ll L=where<<(high-h-1);
        ll R=(where+1)<<(high-h-1);
        if(r<=L || R<=l){return err_T;}
        if(h==high-1){return tree[h][where].F;}
        if(l<=L && R<=r){return tree[h][where].F;}
        else{
            update(h+1,where*2,L,R,tree[h][where].S);
            update(h+1,where*2+1,L,R,tree[h][where].S);
            tree[h][where].S=err_U;
            T ret=err_T;
            ret=F(ret,search(h+1,where*2,l,r));
            ret=F(ret,search(h+1,where*2+1,l,r));
            return ret;
        }
        return err_T;
    }
    
public:
    late_seg_tree(ull size,T err_T,U err_U):err_T(err_T),err_U(err_U){
        err=1e18+7;
        high=bit_size(size)+1;
        tree.resize(high);
        for(int i=0;i<high;i++){
            tree[i].resize(1<<i,{err_T,err_U});
        }
    }
    
    late_seg_tree(vector<T> t,T err_T,U err_U):err_T(err_T),err_U(err_U){
        err=1e18+7;
        high=bit_size(t.size())+1;
        tree.resize(high);
        for(int i=0;i<high;i++){
            tree[i].resize(1<<i,{err_T,err_U});
        }
        for(int i=0;i<t.size();i++){
            tree[high-1][i]={t[i],err_U};
        }
        for(ll h=high-2;h>=0;h--){
            for(int i=0;i<tree[h].size();i++){
                tree[h][i].F=F(tree[h+1][i*2].F,tree[h+1][i*2+1].F);
            }
        }
    }
    
    void update(ll l,ll r,U u){
        update(0,0,l,r,u);
    }
    
    T search(ll l,ll r){
        return search(0,0,l,r);
    }
};



int main(){
    ll n,m;
    deque<pll> a;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        ll b;
        cin>>b;
        a.push_back({b,0});
    }
    for(int i=0;i<m;i++){
        ll b;
        cin>>b;
        a.push_back({b,1});
    }
    sort(a.begin(),a.end());
    while(a.size()>0 && a[0].S==0){a.pop_front(); n--;}
    while(a.size()>0 && a[a.size()-1].S==0){a.pop_back(); n--;}
    vector<pll> X(n,{-1,-1});
    ll left=a[0].F;
    ll count=0;
    for(int i=0;i<a.size();i++){
        if(a[i].S==1){left=a[i].F;}
        else{X[count].F=a[i].F-left; count++;}
    }
    count--;
    for(ll i=a.size()-1;i>=0;i--){
        if(a[i].S==1){left=a[i].F;}
        else{X[count].S=left-a[i].F; count--;}
    }
    X=press(X,2,2);
    late_seg_tree<ll,ll> tree(X.size()*2+1000,0,0);
    tree.update(0,1,1);
    ll ans=1;
    sort(X.begin(),X.end());
    vector<vector<ll>> Y;
    for(int i=0;i<X.size();i++){
        if(i==0 || X[i].F!=X[i-1].F){Y.push_back(vector<ll>());}
        if(i!=0 && X[i]==X[i-1]){continue;}
        Y[Y.size()-1].push_back(X[i].S);
    }
    for(int i=0;i<Y.size();i++){
        vector<ll> d;
        for(int t=0;t<Y[i].size();t++){
            d.push_back(tree.search(0,Y[i][t]));
        }
        for(int t=0;t<Y[i].size();t++){
            tree.update(Y[i][t],Y[i][t]+1,d[t]);
            ans+=d[t];
            ans%=MOD;
        }
    }
    ans%=MOD;
    cout<<ans<<endl;
    
    return 0;
}

//区間加算、区間和
template<typename T,typename U>
T late_seg_tree<T,U>::F(T a,T b){
    return (a+b)%MOD;
}

template<typename T,typename U>
T late_seg_tree<T,U>::G(T a,U b,ll where){
    return (a+b)%MOD;
}

template<typename T,typename U>
U late_seg_tree<T,U>::H(U a,U b){
    return (a+b)%MOD;
}

template<typename T,typename U>
T late_seg_tree<T,U>::I(T a,U b,ll l,ll r){
    return (a+b*(r-l))%MOD;
}

Measured memory_bytes: 18488