#include <bits/stdc++.h>
#include <boost/functional/hash/hash.hpp>

using lnt = long long int;
using Pl = std::pair<lnt, lnt>;

template<class T>
using VC = std::vector<T>;

template<class T>
using VVC = VC<VC<T>>;

using Vl = VC<lnt>;
using VVl = VC<Vl>;

#define FS first
#define SC second

#define EP emplace

#define PB push_back
#define BI back_inserter
#define BG begin()
#define ED end()

#define LB lower_bound
#define UB upper_bound

#define MAX max_element
#define MIN min_element

#define LP(n) for (lnt _ = 0; _ < (n); _++)
#define RP(i, n) for (lnt i = 0; i < (n); i++)            // 0, 1, ..., n-1
#define IR(i, n) for (lnt i = (n)-1; i >= 0; i--)      // n-1, n-2, ..., 0
#define FR(i, a, b) for (lnt i = (a); i < (b); i++)       // a, a+1, ..., b-1
#define IF(i, a, b) for (lnt i = (b)-1; i >= (a); i--) // b-1, b-2, ..., a
#define AL(a) a.begin(), a.end()
#define DISPLAY_DOUBLE(d) (cout << scientific << setprecision(15) << (d))
#define INF (lnt)(1e18)

lnt MOD = (1e9 + 7); // AtCoderのMOD

//グローバル変数のMODを変更する
inline void CHANGE_MOD(const lnt &n) {
  MOD = n;
}

// 習慣付けの為'int'を一切タイプしない
#define MAIN int main

// 各アルゴリズムをlntに揃える
template <class InputIterator, class T>
lnt inline CN(const InputIterator &first, const InputIterator &last,
               const T &value) {
  return std::count(first, last, value);
}

template <class T> lnt inline SZ(const T &sequence) {
  return (lnt)(sequence.size());
}

lnt inline AB(const lnt &value) { return std::abs(value); }

lnt inline MA(const lnt &value1, const lnt &value2) {
  return std::max(value1, value2);
}

lnt inline MI(const lnt &value1, const lnt &value2) {
  return std::min(value1, value2);
}

template <class InputIterator>
lnt inline AC(const InputIterator &first, const InputIterator &last,
               const lnt &init = 0) {
  return std::accumulate(first, last, init);
}

template <class InputIterator, class BinaryOperation>
lnt inline AC(const InputIterator &first, const InputIterator last,
               const lnt init, const BinaryOperation binary_op) {
  return std::accumulate(first, last, init, binary_op);
}

//同じ文字を繰り返す文字列
std::string STR(const lnt &n, const char &c) {
  std::string s;
  for (lnt _ = 0; _ < n; _++) {
    s.push_back(c);
  }
  return s;
}

// unordered_set，unordered_mapの為のハッシュの拡張
template <class T> struct boost_hash {
  inline std::size_t operator()(const T &val) const {
    return boost::hash_value(val);
  }
};

template <class T> using ust = std::unordered_set<T, boost_hash<T>>;
template <class T, class S> using ump = std::unordered_map<T, S, boost_hash<T>>;

using Sl = ust<lnt>;
using Ml = ump<lnt, lnt>;

// pythonのsetdefaultメソッド
template <class T, class S>
S &setdefault(ump<T, S> &map, const T &key, const S &val) {
  if (map.count(key)) {
    return map.at(key);
  }
  map.emplace(key, val);
  return map.at(key);
}

// next_partial_permutation関数
template <class BidirectionalIterator>
bool next_partial_permutation(BidirectionalIterator first,
                              BidirectionalIterator middle,
                              BidirectionalIterator last) {
  reverse(middle, last);
  return next_permutation(first, last);
}

template <class BidirectionalIterator, class Compare>
bool next_partial_permutation(BidirectionalIterator first,
                              BidirectionalIterator middle,
                              BidirectionalIterator last, const Compare comp) {
  reverse(middle, last, comp);
  return next_permutation(first, last, comp);
}

// vector<lnt>({first, first+1, ..., first + size - 1})を生成
std::vector<lnt> init_comb(const lnt size, const lnt first = 0) {
  std::vector<lnt> v;
  for (lnt i = 0; i < size; i++) { v.push_back(i + first); }
  return v;
}

// next_combination関数
// vector<lnt>の昇順列vと, 数Nを入力すると， {順列:N未満の数からなる相異なる#v要素の昇順列}
// の中で， 辞書順でvを次の順列に変更し， trueを返す． もし最後の順列だったら， 何もせずfalseを返す.
// 例：v = {0, 1}, N = 4 なら， {0, 1} → {0, 2} → {0, 3} → {1, 2} → {1, 3} → {2, 3}
bool next_combination(std::vector<lnt> &v, const lnt last) {
  if (SZ(v) == 1 and v.at(0) != last - 1) {
    v.at(0)++;
    return true;
  }
  if (SZ(v) == 1) {
    return false;
  }
  if (SZ(v) > 1) {
    std::vector<lnt> w = v;
    w.erase(w.begin());
    if (next_combination(w, last)) {
      v = std::vector<lnt>(1, v.at(0));
      v.insert(v.end(), w.begin(), w.end());
      return true;
    }
    if (v.at(0) == last - SZ(v)) {
      return false;
    }
    v = init_comb(SZ(v), v.at(0) + 1);
    return true;
  } else
    return false;
}

// n以下の素数列挙
std::vector<lnt> Primes(const lnt n) {
  if (n < 2) {
    return std::vector<lnt>(0);
  }

  std::vector<lnt> vcPri, vcTab(n - 1);
  for (lnt i = 2; i < n + 1; i++) {
    vcTab[i - 2] = i;
  }

  const lnt nRoot = sqrt(n);
  while (vcTab[0] <= nRoot) {
    vcPri.push_back(vcTab[0]);
    vcTab.erase(vcTab.begin());
    std::vector<lnt> vcTab_fil;
    vcTab_fil.reserve(SZ(vcTab));
    std::copy_if(vcTab.begin(), vcTab.end(), back_inserter(vcTab_fil),
                 [&vcPri](lnt x) -> bool { return x % vcPri.back(); });
    vcTab = vcTab_fil;
    if (vcTab.empty()) {
      break;
    }
  }

  vcPri.reserve(vcPri.size() + vcTab.size());
  vcPri.insert(vcPri.end(), vcTab.begin(), vcTab.end());
  return vcPri;
}

// 素数列挙Primes(n)のグローバルリスト化
// デフォルトのサイズは0
std::vector<lnt> vcPRIMES_PREPARED = Primes(0);

//素数列挙Primes(n)のグローバルリスト化におけるリストサイズ指定関数
inline void SPECIFY_LISTSIZE_PRIMES(const lnt max_size) {
  vcPRIMES_PREPARED = Primes(max_size);
}

// 素因数分解:PrimeDecomp(n)
// 2番目の引数にはPrimes(k) (kは十分大 >= floor(sqrt(n))) を入れる
ump<lnt, lnt>
PrimeDecomp(const lnt n,
            const std::vector<lnt> &vcPrimesRoot_n = vcPRIMES_PREPARED) {
  if (n < 2) {
    return ump<lnt, lnt>();
  }

  ump<lnt, lnt> PrimeDecomp;

  lnt m = n;
  for (lnt p : vcPrimesRoot_n) {
    while (m % p == 0) {
      m /= p;
      if (PrimeDecomp.count(p)) {
        PrimeDecomp[p]++;
      } else {
        PrimeDecomp.emplace(p, 1);
      }
    }
  }
  if (m != 1) {
    PrimeDecomp.emplace(m, 1);
  }
  if (vcPrimesRoot_n.empty()) {
    std::cout << "Warning! The SPECIFY_LISTSIZE_PRIMES function is not called."
              << "\n";
  }
  return PrimeDecomp;
}

// 約数列挙:Divisors(n)
// 2番目の引数にはPrimes(k) (kは十分大 >= floor(sqrt(n))) を入れる
std::vector<lnt>
Divisors(const lnt n,
         const std::vector<lnt> &vcPrimesRoot_n = vcPRIMES_PREPARED) {
  std::vector<lnt> vcDiv(1, 1), vcTable;
  auto mpPD = PrimeDecomp(n, vcPrimesRoot_n);
  for (auto itrPD = mpPD.begin(); itrPD != mpPD.end(); itrPD++) {
    lnt nPri = itrPD->first, nMulti = itrPD->second;
    vcTable.resize(vcDiv.size() * (nMulti + 1));
    for (lnt i = 0; i < nMulti + 1; i++) {
      std::transform(vcDiv.begin(), vcDiv.end(),
                     vcTable.begin() + (i * vcDiv.size()),
                     [nPri, i](lnt x) { return x * pow(nPri, i); });
    }
    vcDiv = vcTable;
  }
  std::sort(vcDiv.begin(), vcDiv.end());
  if (vcPrimesRoot_n.empty()) {
    std::cout << "Warning! The SPECIFY_LISTSIZE_PRIMES function is not called."
              << "\n";
  }
  return vcDiv;
}

//最大公約数:gcd(n, m) (gcd(0, 0)=0)
lnt GCD(const lnt n, const lnt m) {
  if (!n || !m) {
    return MA(AB(n), AB(m));
  }
  lnt nDivided = MA(n, m), nDividing = MI(n, m);
  while (nDivided % nDividing) {
    nDivided = nDivided % nDividing;
    std::swap(nDivided, nDividing);
  }
  return AB(nDividing);
}

//最小公倍数:lcm(n, m)
lnt LCM(const lnt n, const lnt m) {
  if (!n && !m) {
    return 0;
  }
  return n / GCD(n, m) * m;
}

// mod2乘
lnt inline SQ(const lnt n, const lnt mod = MOD) {
  return ((n % mod) * (n % mod)) % mod;
}

// mod冪乗
lnt POW(const lnt x, const lnt y, const lnt mod = MOD) {
  if (x >= 0 and y >= 0) {
    if (y == 0) {
      return 1 % mod;
    }
    if (y == 1) {
      return x % mod;
    }
    if (y % 2 == 0) {
      return SQ(POW(x, y / 2, mod), mod);
    }
    return SQ(POW(x, y / 2, mod), mod) * (x % mod) % mod;
  }
  std::cout << "Warning!"
            << "\n";
  return 0;
}

// mod 2の冪
lnt inline BIT(const lnt i) {
  if (i >= 0) {
    return POW(2, i);
  }
  std::cout << "Warning!"
            << "\n";
  return 0;
}

// long long まで許すSQ
lnt inline LSQ(const lnt n) { return n * n; }

// long long まで許すPOW
lnt LPOW(const lnt x, const lnt y) {
  if (x >= 0 and y >= 0) {
    if (y == 0) {
      return 1;
    }
    if (y == 1) {
      return x;
    }
    if (y % 2 == 0) {
      return LSQ(LPOW(x, y / 2));
    }
    return LSQ(LPOW(x, y / 2)) * x;
  }
  std::cout << "Warning!"
            << "\n";
  return 0;
}

// long longまで許すBIT
lnt inline LBIT(const lnt i) {
  if (i >= 0) {
    return LPOW(2, i);
  }
  std::cout << "Warning!"
            << "\n";
  return 0;
}

// n以下の階乗/mod階乗のリストを生成　
std::vector<lnt> vcFACT(const lnt n, const lnt mod = MOD) {
  if (n >= 0) {
    std::vector<lnt> vcFact = {1 % mod};
    lnt fact = 1 % mod;
    for (lnt k = 1; k < n + 1; k++) {
      fact = (fact * (k % mod)) % mod;
      vcFact.push_back(fact);
    }
    return vcFact;
  }
  std::cout << "Warning!　The 1st argument is negative!"
            << "\n";
  return std::vector<lnt>(0);
}

// n以下のmod階乗の逆元のリストを生成(mod:素数を想定)
std::vector<lnt> vcINVFACT(const lnt n, const lnt mod = MOD) {
  std::vector<lnt> vcInvFact;
  lnt invfact = POW(vcFACT(n, mod).at(n), mod - 2);
  vcInvFact.push_back(invfact);
  for (lnt k = n; k > 0; k--) {
    invfact = invfact * (k % mod) % mod;
    vcInvFact.push_back(invfact);
  }
  std::reverse(vcInvFact.begin(), vcInvFact.end());
  return vcInvFact;
}

// mod階乗のリストvcFACT(n, MOD)，mod階乗の逆元リストvcINVFACT(n, MOD)の
//グローバルリスト化 デフォルトのサイズは0
std::vector<lnt> vcMODFACT_PREPARED = vcFACT(0, MOD);
std::vector<lnt> vcMODINVFACT_PREPARED = vcINVFACT(0, MOD);

// mod階乗リストvcFACT(n, mod)，mod階乗の逆元リストvcINVFACT(n, mod)の，
// グローバルリスト化におけるリストサイズ・mod指定関数
inline void SPECIFY_LISTSIZE_MODFACT(const lnt max_size,
  const lnt mod = MOD) {
  vcMODFACT_PREPARED = vcFACT(max_size, mod);
}
inline void SPECIFY_LISTSIZE_MODINVFACT(const lnt max_size,
  const lnt mod = MOD) {
  vcMODINVFACT_PREPARED = vcINVFACT(max_size, mod);
}

// 階乗
// mod > 0．2番目の引数にはvcFACT(m, mod)を入れる
// (m >= n:十分大)
lnt inline FACT(const lnt n,
                const std::vector<lnt> &vcModFact = vcMODFACT_PREPARED) {
  if (vcModFact.empty()) {
    std::cout << "Warning! The SPECIFY_LISTSIZE_PRIMES function"
              << " has not been called."
              << "\n";
  }

  return vcModFact.at(n);
}

// 順列の数
// mod:素数を想定．4, 5番目の引数にはvcFACT(m1, mod)，vcINVFACT(m2, mod)を入れる
// (m1 >= n, m2 >= n-k :十分大)
lnt PERM(const lnt n, const lnt k, const lnt mod = MOD,
         const std::vector<lnt> &vcModFact = vcMODFACT_PREPARED,
         const std::vector<lnt> &vcModInvFact = vcMODINVFACT_PREPARED) {
  if (k >= 0) {
    return vcModFact.at(n) * vcModInvFact.at(n - k) % mod;
  }
  std::cout << "Warning!"
            << "\n";
  std::cout << "Note that 4th, 5th argument : vcFact(m1, mod), vcFact(m2, mod)."
            << "\n";
  if (vcModFact.empty()) {
    std::cout << "Warning! The SPECIFY_LISTSIZE_PRIMES function is not called."
              << "\n";
  }
  if (vcModInvFact.empty()) {
    std::cout << "Warning! The SPECIFY_LISTSIZE_PRIMES function is not called."
              << "\n";
  }

  return 0;
}

//二項係数
// mod:素数を想定．4, 5番目の引数にはvcFACT(m1, mod)，vcINVFACT(m2, mod)を入れる
// (m1 >= n, m2 >= n-k, k :十分大)
lnt inline COMB(const lnt n, const lnt k, const lnt mod = MOD,
                const std::vector<lnt> &vcModFact = vcMODFACT_PREPARED,
                const std::vector<lnt> &vcModInvFact = vcMODINVFACT_PREPARED) {
  return PERM(n, k, mod, vcModFact, vcModInvFact) * vcModInvFact.at(k) % mod;
}

//重複組み合わせの数
// mod:素数を想定．4, 5番目の引数にはvcFACT(m1, mod)，vcINVFACT(m2,mod)を入れる
// (m1 >= n+k-1, m2 >= n-1, k :十分大)
lnt inline HCOMB(const lnt n, const lnt k, const lnt mod = MOD,
                 const std::vector<lnt> &vcModFact = vcMODFACT_PREPARED,
                 const std::vector<lnt> &vcModInvFact = vcMODINVFACT_PREPARED) {
  return COMB(n + k - 1, k, mod, vcModFact, vcModInvFact);
}

// 非負整数valueのbase進数表示でのposition桁目を表示
lnt inline MASK(const lnt value, const lnt position, const lnt base = 10) {
  if (value >= 0 and base >= 2) {
    return (value / LPOW(base, position)) % base;
  }
  std::cout << "WARNING! The MASK fucntion is applyed in a wrong manner."
            << "\n";
  return 0;
}

// ビットマスク
lnt inline BMASK(const lnt value, const lnt position) {
  return MASK(value, position, 2);
}

// MASKにおいて，position桁目に数字がない時0ではなくbaseを返す
lnt inline DIGIT(const lnt value, const lnt position, const lnt base = 10) {
  if (value >= 0 and base >= 2) {
    if (value == 0) {
      if (position == 0) {
        return 0;
      }
      return base;
    }
    if (value < LPOW(base, position)) {
      return base;
    }
    return MASK(value, position, base);
  }

  std::cout << "WARNING!"
            << "\n";
  return 0;
}

// base=2のDIGIT
lnt inline BDIGIT(const lnt value, const lnt position) {
  return DIGIT(value, position, 2);
}

// ポテンシャル付きUnion-Find木
template <class T> class UnionFind {
private:
  ump<T, T> par;
  ump<T, lnt> rank;
  ump<T, lnt> diff_from_par;
  ump<T, lnt> sz;
  lnt nTree = 0;
  lnt weight(const T &);

public:
  UnionFind<T>();
  UnionFind<T>(const ust<T> &);
  T find(const T &);
  lnt diff(const T &, const T &);
  bool unite(const T &, const T &, const lnt = 0);
  bool equi(const T &x, const T &y) { return find(x) == find(y); }
  lnt size_at(const T &x) { return sz.at(find(x)); }
  lnt n_tree() const { return nTree; }
};

template <class T> UnionFind<T>::UnionFind(const ust<T> &st) {
  par.reserve(SZ(st));
  rank.reserve(SZ(st));
  diff_from_par.reserve(SZ(st));
  sz.reserve(SZ(st));
  for (T x : st) {
    par.emplace(x, x);
    rank.emplace(x, 0);
    diff_from_par.emplace(x, 0);
    sz.emplace(x, 1);
  }
  nTree = SZ(st);
}

// 経路圧縮しながらrootを返す
template <class T> T UnionFind<T>::find(const T &x) {
  if (par.at(x) == x) {
    return x;
  }
  T root = find(par.at(x));
  diff_from_par.at(x) += diff_from_par.at(par.at(x));
  return par.at(x) = root;
}

// rootを基準としたポテンシャル
template <class T> lnt UnionFind<T>::weight(const T &x) {
  find(x);
  return diff_from_par.at(x);
}

// yを基準としたxのポテンシャルを返す
// 異なる木に対するdiff関数は意味を持たないので，警告も出力
template <class T> lnt UnionFind<T>::diff(const T &x, const T &y) {
  if (not equi(x, y)) {
    std::cout << "Warning! The roots of x and y are not same."
              << "\n";
  }
  return weight(x) - weight(y);
}

// diff(x, y) = w となるようにxのtreeとyのtreeを繋ぐ
// xのtreeとyのtreeが既に同じで，diff(x, y) ≠ w　なら何もせずにfalseを返す
template <class T>
bool UnionFind<T>::unite(const T &x, const T &y, const lnt w) {
  T p = find(x);
  T q = find(y);
  if (p == q) {
    if (diff(x, y) == w) {
      return true;
    }
    return false;
  }
  lnt v = w + weight(y) - weight(x);
  if (rank.at(p) > rank.at(q)) {
    std::swap(p, q);
    v = -v;
  }
  if (rank.at(p) == rank.at(q)) {
    rank.at(q)++;
  }
  par.at(p) = q;
  diff_from_par.at(p) = v;
  sz.at(q) += sz.at(p);
  nTree--;
  return true;
}

// UnionFind<lnt>
template <> class UnionFind<lnt> {
private:
  ump<lnt, lnt> par;
  ump<lnt, lnt> rank;
  ump<lnt, lnt> diff_from_par;
  ump<lnt, lnt> sz;
  lnt nTree = 0;
  lnt weight(const lnt);

public:
  UnionFind<lnt>();
  UnionFind<lnt>(const ust<lnt> &);
  UnionFind<lnt>(const lnt);
  lnt find(const lnt);
  lnt diff(const lnt, const lnt);
  bool unite(const lnt, const lnt, const lnt = 0);
  bool equi(const lnt x, const lnt y) { return find(x) == find(y); }
  lnt size_at(const lnt x) { return sz.at(find(x)); }
  lnt n_tree() const { return nTree; }
};

UnionFind<lnt>::UnionFind(const ust<lnt> &st) {
  par.reserve(SZ(st));
  rank.reserve(SZ(st));
  diff_from_par.reserve(SZ(st));
  sz.reserve(SZ(st));
  for (lnt x : st) {
    par.emplace(x, x);
    rank.emplace(x, 0);
    diff_from_par.emplace(x, 0);
    sz.emplace(x, 1);
  }
  nTree = SZ(st);
}

UnionFind<lnt>::UnionFind(const lnt num) {
  par.reserve(num);
  rank.reserve(num);
  diff_from_par.reserve(num);
  sz.reserve(num);
  RP(i, num) {
    par.emplace(i, i);
    rank.emplace(i, 0);
    diff_from_par.emplace(i, 0);
    sz.emplace(i, 1);
  }
  nTree = num;
}

// 経路圧縮しながらrootを返す
lnt UnionFind<lnt>::find(const lnt x) {
  if (par.at(x) == x) {
    return x;
  }
  lnt root = find(par.at(x));
  diff_from_par.at(x) += diff_from_par.at(par.at(x));
  return par.at(x) = root;
}

// rootを基準としたポテンシャル
lnt UnionFind<lnt>::weight(const lnt x) {
  find(x);
  return diff_from_par.at(x);
}

// yを基準としたxのポテンシャルを返す
// 異なる木に対するdiff関数は意味を持たないので，警告も出力
lnt UnionFind<lnt>::diff(const lnt x, const lnt y) {
  if (not equi(x, y)) {
    std::cout << "Warning! The roots of x and y are not same."
              << "\n";
  }
  return weight(x) - weight(y);
}

// diff(x, y) = w となるようにxのtreeとyのtreeを繋ぐ
// xのtreeとyのtreeが既に同じで，diff(x, y) ≠ w　なら何もせずにfalseを返す
bool UnionFind<lnt>::unite(const lnt x, const lnt y, const lnt w) {
  lnt p = find(x);
  lnt q = find(y);
  if (p == q) {
    if (diff(x, y) == w) {
      return true;
    }
    return false;
  }
  lnt v = w + weight(y) - weight(x);
  if (rank.at(p) > rank.at(q)) {
    std::swap(p, q);
    v = -v;
  }
  if (rank.at(p) == rank.at(q)) {
    rank.at(q)++;
  }
  par.at(p) = q;
  diff_from_par.at(p) = v;
  sz.at(q) += sz.at(p);
  nTree--;
  return true;
}

//セグメント木
/*SegmentTree<X, M>(n1, fx, fa, fm, ex, em):
    (X, ex, fx), (M, em, fm): モノイド,
    写像fa: X * M -> X によって, XはM-monoid,
    n1: セグメント木の葉の数(実際の内部的な葉の数は, n1 <= 2^m なる最小の2^m = n)
  set(i, x): i番目の葉にxをセット.
  build(): 葉からセグメント木を構築.
  update(a, b, m): [a, b)の要素xをfm(x, m)に更新. O(log(n))
  query(a, b): [a, b)全てにfxを作用させた値を取得. O(log(n))
  参考: https://algo-logic.info/segment-tree/
*/
template <class X, class M>
class SegmentTree {
  using FX = std::function<X(X, X)>;
  using FM = std::function<M(M, M)>;
  using FA = std::function<X(X, M)>;

private:
  lnt n; //葉の数(2の冪乗)
  FX fx;
  FM fm;
  FA fa;
  const X ex;
  const M em;
  std::vector<X> dat; //完全二分木全体の配列
  std::vector<M> lazy; //遅延評価用の配列
  void lupd(const lnt); //局所的な更新
  void upd_sub(const lnt, const lnt, const M &,
    const lnt, const lnt, const lnt); //区間更新のサブ関数
  X query_sub(const lnt, const lnt, const lnt, const lnt, const lnt);
  //クエリ区間走行中のサブクエリ

public:
  SegmentTree(const lnt, const FX &, const FM &, const FA &,
    const X &, const M &); //コンストラクタ
  void set(const lnt, const X &); //葉に値をセット
  void build(); //セットされた値を用いて，セグメント木を構成
  void update(const lnt, const lnt, const M &); //区間更新
  X query(const lnt a, const lnt b); //クエリ区間走行
};

//コンストラクタ
template <class X, class M> SegmentTree<X, M>::SegmentTree(
  const lnt n1, const FX &fx_, const FM &fm_,
  const FA &fa_, const X &ex_, const M &em_)
  : n(), fx(fx_), fa(fa_), fm(fm_), ex(ex_), em(em_),
  dat(n1 * 4, ex), lazy(n1 * 4, em){ // n1は2の冪とは限らない→2ではなく4
  lnt x = 1;
  while (n1 > x) { x *= 2; }
  n = x;
};

template <class X, class M> void SegmentTree<X, M>::set(
  const lnt i, const X &x) {
  dat.at(i + n - 1) = x;
}; //葉の内部的な位置はn-1ずれる
template <class X, class M> void SegmentTree<X, M>::build() {
  for (lnt k = n-2; k>=0; k--) {
    dat.at(k) = fx(dat.at(2*k + 1), dat.at(2*k + 2));
    //kの子は(存在するなら)2*k+1,2*k+2
  }
};

//局所的な更新: 位置kで，lazyにプールしてある値mを子に伝播し，自身をfa(・, m)に更新
template <class X, class M> void SegmentTree<X, M>::lupd(const lnt k) {
  if (lazy.at(k) == em) { return; } //何もプールされていなければ終了
  if (k < n - 1) { //子に伝播(予め伝播先に値があるなら, fmを用いてプール値を更新)
    lazy.at(2*k + 1) = fm(lazy.at(2*k + 1), lazy.at(k));
    lazy.at(2*k + 2) = fm(lazy.at(2*k + 2), lazy.at(k));
  }
  //自身を更新
  dat.at(k) = fa(dat.at(k), lazy.at(k));
  lazy.at(k) = em; //更新後はlazyを空に
};

/*区間更新(内部的には,実際に全ての更新はせず,必要最低限の更新のみし,
他はできるだけ親のlazyにプールしておくだけ)update(a, b, m)のサブ関数 */
template <class X, class M> void SegmentTree<X, M>::upd_sub(
  const lnt a, const lnt b, const M &m,
  const lnt k, const lnt l, const lnt r) {
  //k: 現在の位置
  //元々の更新区間:[a, b), fa(・, m)を使って更新, 現在の区間:[l, r)

  if (a <= l && r <= b) { //[l, r)が[a, b)に含まれる場合

    /*この場合は,mによる更新を行う.ただし,更新の際は古い値がプールされている場合を考慮する.
      (根でなければ)親にこの更新後の値が送り返される事になる*/
    lazy.at(k) = fm(lazy.at(k), m); lupd(k);

    /*これより下の全ての子も(遅延評価でなければ)mにより更新させるはずだが,
      実際はすぐ下の子にプールさせておくだけで,更新しない(これが計算量の肝)*/
    return;
  }

  if (a < r && l < b) { //[l, r)と[a, b)の一部区間が被る場合

    /*自身はmによる更新対象ではないが,子がmによる更新対象となり変化する可能性がある.
      そこで最終的には親=fx(子1, 子2)の関係を保てるよう,子以降を調べてから,
      親=fx(子1, 子2)とする*/

    lupd(k); //古い値がプールされていれば， 子への伝播と自身の更新を行っておく

    upd_sub(a, b, m, 2*k + 1, l, (l+r)/2); //左の子を調べる
    upd_sub(a, b, m, 2*k + 2, (l+r)/2, r); //右の子を調べる

    //子以下は更新処理が完了したため,親=fx(子1, 子２)とし直す.
    dat.at(k) = fx(dat.at(2*k + 1), dat.at(2*k + 2));
    return;
  }

  //[l, r)と[a, b)が交わらない時は，自身と子以下にmによる変化は起き得ないため,何もしない
};

/*区間更新 update(a, b, m)
  更新区間:[a, b), fa(・, m)を使って更新 */
template <class X, class M> void SegmentTree<X, M>::update(
  const lnt a, const lnt b, const M &m) { upd_sub(a, b, m, 0, 0, n); };

//クエリ走行query(a, b)のサブクエリ
template <class X, class M> X SegmentTree<X, M>::query_sub(
  const lnt a, const lnt b, const lnt k, const lnt l, const lnt r) {
  //k: 現在の位置
  //元々のクエリ走行区間:[a, b), 現在の区間:[l, r)

  if (a <= l && r <= b) { //[l, r)が[a, b)に含まれる場合

    //この場合は,親のサブクエリに自身の値を返す.ただし,値がプールされている場合を考慮する.
    lupd(k); return dat.at(k);
  }

  if (a < r && l < b) { //[l, r)と[a, b)の一部区間が被る場合

    /*この場合は,自身の値をそのまま親のサブクエリに返すわけにはいかない.
      すっぽり含まれるような子に行き着くまで,子以下を調べる.
      最終的に調べおわったあと,返ってきた値にfx(・,・)を作用させ，親のサブクエリに返す*/

    lupd(k); //古い値がプールされていれば， 子への伝播と自身の更新を行っておく

    X xl = query_sub(a, b, 2*k + 1, l, (l+r)/2); //左の子のサブクエリを処理
    X xr = query_sub(a, b, 2*k + 2, (l+r)/2, r); //右の子のサブクエリを処理

    //子のサブクエリが完了したため,渡された値を用いて親のサブクエリに値を返す
    return fx(xl, xr);
  }

  //[l, r)と[a, b)が交わらない時は，単位元exを親のサブクエリに返す.
  return ex;
};

/*クエリ走行query(a, b)
  クエリ走行区間:[a, b), fxを区間に作用させた結果を返す*/
template <class X, class M> X SegmentTree<X, M>::query(
  const lnt a, const lnt b) { return query_sub(a, b, 0, 0, n); };

using namespace std;

MAIN() {
  lnt H, W; cin >> H >> W;
  lnt A, B; cin >> A >> B;

  SPECIFY_LISTSIZE_MODFACT(W+H);
  SPECIFY_LISTSIZE_MODINVFACT(W+H);

  lnt res = 0;

  RP(h, H-A) {
    res += HCOMB(B, h) * HCOMB(W-B, H-1-h) % MOD;
    res %= MOD;
  }

  cout << res << endl;
}


Measured memory_bytes: 8540