#include <bits/stdc++.h>
#define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
#define pr(...) cerr<< GET_MACRO(__VA_ARGS__,pr8,pr7,pr6,pr5,pr4,pr3,pr2,pr1)(__VA_ARGS__) <<endl
#define pr1(a) (#a)<<"="<<(a)<<" "
#define pr2(a,b) pr1(a)<<pr1(b)
#define pr3(a,b,c) pr1(a)<<pr2(b,c)
#define pr4(a,b,c,d) pr1(a)<<pr3(b,c,d)
#define pr5(a,b,c,d,e) pr1(a)<<pr4(b,c,d,e)
#define pr6(a,b,c,d,e,f) pr1(a)<<pr5(b,c,d,e,f)
#define pr7(a,b,c,d,e,f,g) pr1(a)<<pr6(b,c,d,e,f,g)
#define pr8(a,b,c,d,e,f,g,h) pr1(a)<<pr7(b,c,d,e,f,g,h)
using namespace std;
using Int = long long;
using _int = int;
using ll = long long;
using Double = long double;
const Int INF = (1LL<<55)+1e9; // ~ 3.6 * 1e16
const Int mod = (1e9)+7;
const Double EPS = 1e-8;
const Double PI = 6.0 * asin((Double)0.5);
using P = pair<Int,Int>;
using T = tuple<Int,Int,Int>;
template<class T> T Max(T &a,T b){return a=max(a,b);}
template<class T> T Min(T &a,T b){return a=min(a,b);}
template<class T1, class T2> ostream& operator<<(ostream& o,pair<T1,T2> p){return o<<"("<<p.first<<","<<p.second<<")";}
template<class T1, class T2, class T3> ostream& operator<<(ostream& o,tuple<T1,T2,T3> t){
  return o<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class T1, class T2> istream& operator>>(istream& i,pair<T1,T2> &p){return i>>p.first>>p.second;}
template<class T> ostream& operator<<(ostream& o,vector<T> &a){Int i=0;for(T t:a)o<<(i++?" ":"")<<t;return o;}
template<class T> istream& operator>>(istream& i,vector<T> &a){for(T &t:a)i>>t;return i;}
template<class T>void prArr(T a,string s=" "){Int i=0;for(T t:a)cout<<(i++?s:"")<<t;cout<<endl;}

class RSAQ{
public: 
  typedef long long ll;

  //マージ可能な主データ型
  struct D{
    ll value;
    D():value(0){} /*適切な値にする!!!!!!*/
    D(ll value):value(value){}
    bool operator < (D a)const {return value < a.value;}
  };

  //遅延用の型  
  struct T{
    Int type; //0 - empty   , 1 - update
    ll value;
    T():type(0),value(0){}
    T(Int type,ll value):type(type),value(value){}
  };

  
  Int n, n_;
  vector<D> dat;
  vector<T> td;
  D returnD = D(0); // 範囲外の時に返す値。
  
  RSAQ(){n=-1;}
  RSAQ(Int n_):n_(n_){
    n=1;
    while(n < n_) n *= 2;
    td.resize(2*n-1,T());
    dat.resize(2*n-1,D());
  }
  
  inline D merge(const D a,const D b)const{return (a.value + b.value)%mod;}
  
  void delay(Int k,Int len){
    if(td[k].type==0) return;
    ll type = td[k].type;
    ll v = td[k].value;
    td[k].type = 0;
    td[k].value = 0;
    len /= 2;
    {
      Int l = k*2+1;
      dat[l].value += v * len;
      td[l].type = type;
      td[l].value += v;
    }
    {
      Int r = k*2+2;
      dat[r].value += v * len;
      td[r].type = type;
      td[r].value += v;
    }
  }

  D write(Int k, D x, Int len){
    dat[k].value += x.value * len;
    td[k].type = 1;
    td[k].value += x.value;
    return dat[k];
  }
  
  D dfs(Int a, Int b, D x, bool flag, Int k, Int l, Int r){
    if(r <= a||b <= l) return flag? dat[k]:returnD;
    if(a <= l && r <= b) return flag? write(k, x, r - l):dat[k];
    delay(k, r - l);
    D vl = dfs(a, b, x, flag, k*2+1, l, (l+r)/2);
    D vr = dfs(a, b, x, flag, k*2+2, (l+r)/2, r);
    return flag? (dat[k] = merge(vl, vr)):merge(vl, vr);
  }

  //[l,r)の値にx加算
  void add(Int l,Int r,ll x){
    assert(l <= r);
    assert(0 <= l && l <= n);
    assert(0 <= r && r <= n);
    dfs(l, r, D(x), true, 0, 0, n);
  }
  
  //[l,r)の合計値を得る
  ll get(Int l,Int r){
    assert(l <= r);
    assert(0 <= l && l <= n);
    assert(0 <= r && r <= n);
    D res = dfs(l, r, D(), false, 0, 0, n);
    return res.value;
  }
};

template <typename T>
class Compress{
public:
  vector<T> X;
  bool ok;
  Compress(){};
  
  Int size(){return X.size();}
  void add(T a){ok = false; X.push_back(a); X.push_back(a-1); X.push_back(a+1);}
  void add(const vector<T> a){for(T x:a) add(x);}
  //void add(const vector<T> &a){for(T x:a) add(x);}
  
  void build(){
    ok = true;
    sort(X.begin(),X.end());
    X.erase(unique(X.begin(),X.end()),X.end());
  }
  
  T getL(T x){assert(ok); return lower_bound(X.begin(),X.end(),x) - X.begin();}
  T getU(T x){assert(ok); return upper_bound(X.begin(),X.end(),x) - X.begin();}
};

signed main(){
  srand((unsigned)time(NULL));
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  Int n,m;
  cin>>n>>m;
  vector<Int>A(n); //Robots
  cin>>A;
  vector<Int>B(m); //exits
  cin>>B;

  auto calc = [&](Int x){
    Int i = lower_bound(B.begin(), B.end(), x) - B.begin();
    if( i - 1 < 0 || i == m ) return P(-1, -1);
    return P(x - B[i-1], B[i] - x);
  };
  
  vector<P> C;
  Compress <Int> R;
  for(Int i=0;i<n;i++){
    Int l, r; tie(l, r) = calc(A[i]);
    if(l == -1 && r == -1) continue;
    C.push_back(P(l, -r));
    R.add(r);
  }
  
  R.add(0); R.build();
  
  sort(C.begin(),C.end());
  C.erase(unique(C.begin(), C.end()), C.end());
  
  RSAQ seg(R.size());
  seg.add(R.getL(0), R.getL(0)+1, 1);
  
  for(auto p:C){
    Int l, r; tie(l, r) = p;
    r = R.getL(-r);
    Int sum = seg.get(0, r);
    seg.add(r, r+1, sum);
  }

  Int ans = seg.get(0, R.size());
  cout<<ans<<endl;
  
  
  return 0;
}


Measured memory_bytes: 31328