Problem p02794 (C++)

Buggy submission (status: Runtime Error):
// #undef _DEBUG
// #pragma GCC optimize("Ofast")
// 不動小数点の計算高速化
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long // todo 消したら動かない intの代わりにsignedを使う
#define ll long long
auto start_time = system_clock::now();
auto past_time = system_clock::now();

#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name

/*@formatter:off*/
//[-n, n)にアクセスできる
// また、外部関数resizeに渡せる
// sizeは[-n, n)でnを返す
template <class T> class mvec {
  vector<T> v;
  int n;

public:
  mvec() : n(0), v(0) {}
  mvec(int n) : n(n), v(n * 2) {}
  mvec(int n, T val) : n(n), v(n * 2, val) {}
  auto &operator[](int i) { return v[i + n]; }
  auto size() { return n; }
  void resize(int sn) {
    assert(n == 0);
    n = sn;
    v.resize(sn * 2);
  }
  auto begin() { return v.begin(); }
  auto rbegin() { return v.rbegin(); }
  auto end() { return v.end(); }
  auto rend() { return v.rend(); }
};
//[]でboolは参照を返さないため特殊化が必要
template <> struct mvec<bool> {
  vector<bool> v;
  int n;
  mvec() : n(0), v(0) {}
  mvec(int n) : n(n), v(n * 2) {}
  mvec(int n, bool val) : n(n), v(n * 2, val) {}
  auto operator[](int i) { return v[i + n]; }
  auto size() { return v.size(); }
  void resize(int sn) {
    assert(n == 0);
    n = sn;
    v.resize(sn * 2);
  }
  auto begin() { return v.begin(); }
  auto rbegin() { return v.rbegin(); }
  auto end() { return v.end(); }
  auto rend() { return v.rend(); }
};
template <class T> ostream &operator<<(ostream &os, mvec<T> &a) {
  int spa = 3;
  for (auto &&v : a) {
    spa = max(spa, (int)(to_string(v).size()) + 1);
  }
  int n = (int)a.size();
  os << endl;
  for (int i = -n; i < n; i++) {
    int need = spa - ((int)to_string(i).size());
    if (i == -n) {
      need -= min(need, spa - ((int)to_string(a[i]).size()));
    }
    while (need--) {
      os << " ";
    }
    os << i;
  }
  os << endl;
  int i = -n;
  for (auto &&v : a) {
    int need = spa - ((int)to_string(v).size());
    if (i == -n) {
      need -= min(need, spa - ((int)to_string(i).size()));
    }
    while (need--) {
      os << " ";
    }
    os << v;
    i++;
  }
  return os;
}
#define mv mvec
#define MV mvec
using mvi = mvec<ll>;
using mvb = mvec<bool>;
using mvs = mvec<string>;
using mvd = mvec<double>;
using mvc = mvec<char>;

#define mvvt0(t) mvec<mvec<t>>
#define mvvt1(t, a) mvec<mvec<t>> a
#define mvvt2(t, a, b) mvec<mvec<t>> a(b)
#define mvvt3(t, a, b, c) mvec<mvec<t>> a(b, mvec<t>(c))
#define mvvt4(t, a, b, c, d) mvec<mvec<t>> a(b, mvec<t>(c, d))
#define mvvi(...)                                                              \
  over4(__VA_ARGS__, mvvt4, mvvt3, mvvt2, mvvt1, mvvt0)(ll, __VA_ARGS__)

template <typename T> mvec<T> make_mv(size_t a) { return mvec<T>(a); }
template <typename T, typename... Ts> auto make_mv(size_t a, Ts... ts) {
  return mvec<decltype(make_mv<T>(ts...))>(a, make_mv<T>(ts...));
}
#define mvni(name, ...) auto name = make_mv<ll>(__VA_ARGS__)

#ifdef _DEBUG
string message;
// https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template <class T, class A = std::allocator<T>>
struct debtor : std::vector<T, A> {
  using std::vector<T, A>::vector;
  template <class U> int deb_v(U a, int v) { return v; }
  template <class U> int deb_v(debtor<U> &a, int v = 0) {
    cerr << a.size() << " ";
    return deb_v(a.at(0), v + 1);
  }
  template <class U> void deb_o(U a) { cerr << a << " "; }
  template <class U> void deb_o(debtor<U> &a) {
    for (int i = 0; i < min((int)a.size(), 15ll); i++) {
      deb_o(a[i]);
    }
    if ((int)a.size() > 15) {
      cerr << "...";
    }
    cerr << endl;
  }
  typename std::vector<T>::reference
  operator[](typename std::vector<T>::size_type n) {
    if (n < 0 || n >= (int)this->size()) {
      int siz = (int)this->size();
      cerr << "vector size = ";
      int dim = deb_v((*this));
      cerr << endl;
      cerr << "out index at  " << n << endl;
      cerr << endl;
      if (dim <= 2) {
        deb_o((*this));
      }
      exit(0);
    }
    return this->at(n);
  }
};
// #define vector debtor
// 区間削除は出来ない
template <class T> struct my_pbds_tree {
  set<T> s;
  auto begin() { return s.begin(); }
  auto end() { return s.end(); }
  auto rbegin() { return s.rbegin(); }
  auto rend() { return s.rend(); }
  auto empty() { return s.empty(); }
  auto size() { return s.size(); }
  void clear() { s.clear(); }
  template <class U> void insert(U v) { s.insert(v); }
  template <class U> void operator+=(U v) { insert(v); }
  template <class F> auto erase(F v) { return s.erase(v); }
  template <class U> auto find(U v) { return s.find(v); }
  template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
  template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
  auto find_by_order(ll k) {
    auto it = s.begin();
    for (ll i = 0; i < k; i++)
      it++;
    return it;
  }
  auto order_of_key(ll v) {
    auto it = s.begin();
    ll i = 0;
    for (; it != s.end() && *it < v; i++)
      it++;
    return i;
  }
};
#define pbds(T) my_pbds_tree<T>
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
  unordered_map<T, U> m;
  my_unordered_map(){};
  auto begin() { return m.begin(); }
  auto end() { return m.end(); }
  auto cbegin() { return m.cbegin(); }
  auto cend() { return m.cend(); }
  template <class V> auto erase(V v) { return m.erase(v); }
  void clear() {
    m.clear();
  } /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
  template <class V> auto find(V v) { return m.find(v); }
  template <class V> auto &operator[](V n) { return m[n]; }
};
#define unordered_map my_unordered_map
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umapu unordered_map<uint64_t, ll>
#define umapip unordered_map<ll, P>

#else
#define endl '\n'
// umapはunorderd_mapになる
// umapiはgp_hash_table

// find_by_order(k) k番目のイテレーター
// order_of_key(k)  k以上が前から何番目か
#define pbds(U)                                                                \
  __gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
                   __gnu_pbds::tree_order_statistics_node_update>

#define umapi __gnu_pbds::gp_hash_table<ll, ll, xorshift>
#define umapp __gnu_pbds::gp_hash_table<P, ll, xorshift>
#define umapu __gnu_pbds::gp_hash_table<uint64_t, ll, xorshift>
#define umapip __gnu_pbds::gp_hash_table<ll, P, xorshift>

#endif
/*@formatter:on*/
struct xorshift {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(std::pair<ll, ll> x) const {
    ll v = ((x.first) << 32) | x.second;
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(v + FIXED_RANDOM);
  }
};
/*@formatter:off*/
template <class U, class L>
void operator+=(
    __gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
                     __gnu_pbds::tree_order_statistics_node_update> &s,
    L v) {
  s.insert(v);
}
// 衝突対策
#define ws ws_

template <class A, class B, class C> struct T2 {
  A f;
  B s;
  C t;
  T2() { f = 0, s = 0, t = 0; }
  T2(A f, B s, C t) : f(f), s(s), t(t) {}
  bool operator<(const T2 &r) const {
    return f != r.f   ? f < r.f
           : s != r.s ? s < r.s
                      : t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
                                    r.s : t > r.t; 大きい順 */
  }
  bool operator>(const T2 &r) const {
    return f != r.f   ? f > r.f
           : s != r.s ? s > r.s
                      : t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
                                    r.s : t > r.t; 小さい順 */
  }
  bool operator==(const T2 &r) const {
    return f == r.f && s == r.s && t == r.t;
  }
  bool operator!=(const T2 &r) const {
    return f != r.f || s != r.s || t != r.t;
  }
};
template <class A, class B, class C, class D> struct F2 {
  A a;
  B b;
  C c;
  D d;
  F2() { a = 0, b = 0, c = 0, d = 0; }
  F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
  bool operator<(const F2 &r) const {
    return a != r.a   ? a < r.a
           : b != r.b ? b < r.b
           : c != r.c ? c < r.c
                      : d < r.d; /*    return a != r.a ? a > r.a : b != r.b ? b
                                    > r.b : c != r.c ? c > r.c : d > r.d;*/
  }
  bool operator>(const F2 &r) const {
    return a != r.a   ? a > r.a
           : b != r.b ? b > r.b
           : c != r.c ? c > r.c
                      : d > r.d; /*        return a != r.a ? a < r.a : b != r.b
                                    ? b < r.b : c != r.c ? c < r.c : d < r.d;*/
  }
  bool operator==(const F2 &r) const {
    return a == r.a && b == r.b && c == r.c && d == r.d;
  }
  bool operator!=(const F2 &r) const {
    return a != r.a || b != r.b || c != r.c || d != r.d;
  }
  ll operator[](ll i) {
    assert(i < 4);
    return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
  }
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
T mt(ll a, ll b, ll c) { return T(a, b, c); }
F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }

//@マクロ省略系 型,構造
#define double long double
// #define pow powl
using dou = double;
const double eps = 1e-9;
// 基本コメントアウト
/*
struct epsdou {    double v;    epsdou(double v = 0) : v(v) {}    template<class
T> epsdou &operator+=(T b) {        v += (double) b;        return (*this);    }
template<class T> epsdou &operator-=(T b) {        v -= (double) b; return
(*this);    }    template<class T> epsdou &operator*=(T b) {        v *=
(double) b;        return (*this);    }    template<class T> epsdou
&operator/=(T b) {        v /= (double) b;        return (*this);    }    epsdou
operator+(epsdou b) { return v + (double) b; }    epsdou operator-(epsdou b) {
return v - (double) b; }    epsdou operator*(epsdou b) { return v * (double) b;
}    epsdou operator/(epsdou b) { return v / (double) b; }    epsdou operator-()
const { return epsdou(-v); }    template<class T> bool operator<(T b) { return v
< (double) b; }    template<class T> bool operator>(T b) { return v > (double)
b; }    template<class T> bool operator==(T b) { return fabs(v - (double) b) <=
eps; }    template<class T> bool operator<=(T b) { return v < (double) b ||
fabs(v - b) <= eps; }    template<class T> bool operator>=(T b) { return v >
(double) b || fabs(v - b) <= eps; }    operator double() { return v; }};istream
&operator>>(istream &iss, epsdou &a) {    iss >> a.v;    return iss;}ostream
&operator<<(ostream &os, epsdou &a) {    os << a.v;    return os;} #define
eps_conr_t(o) template<class T> epsdou operator o(T b, epsdou a){return a.v o
(dou)b;} #define eps_conl_t(o) template<class T> epsdou operator o(epsdou a, T
b){return a.v o (dou)b;}
eps_conl_t(+)eps_conl_t(-)eps_conl_t(*)eps_conl_t(/)eps_conr_t(+)eps_conr_t(-)eps_conr_t(*)eps_conr_t(/)
#undef double
#define double epsdou
*/

#define ull unsigned long long
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using mvp = mvec<P>;
using mvt = mvec<T>;
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()

#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define upd update
#define sstream stringstream

#define maxq 1
#define minq -1

#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam1(ret) [&](auto &v) { return ret; }
#define lam2(v, ret) [&](auto &v) { return ret; }
#define lam(...) over2(__VA_ARGS__, lam2, lam1)(__VA_ARGS__)
#define lamr(right) [&](auto &p) { return p right; }

// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;

// #define V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>> a
#define vvt2(t, a, b) vector<vector<t>> a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b, vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b, vector<t>(c, d))

#define vvi(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
#define vv(type, ...)                                                          \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(type, __VA_ARGS__)

template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define vn(type, name, ...) auto name = make_v<type>(__VA_ARGS__)

#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
// 任意のマクロサポート用 使う度に初期化する
int index_, v1_, v2_, v3_;

template <class T> struct pq {
  priority_queue<T, vector<T>, greater<T>> q; /*小さい順*/
  T su = 0;
  void clear() {
    q = priority_queue<T, vector<T>, greater<T>>();
    su = 0;
  }
  void operator+=(T v) {
    su += v;
    q.push(v);
  }
  T sum() { return su; }
  T top() { return q.top(); }
  void pop() {
    su -= q.top();
    q.pop();
  }
  T poll() {
    T ret = q.top();
    su -= ret;
    q.pop();
    return ret;
  }
  ll size() { return q.size(); }
};
template <class T> struct pqg {
  priority_queue<T> q; /*大きい順*/
  T su = 0;
  void clear() {
    q = priority_queue<T>();
    su = 0;
  }
  void operator+=(T v) {
    su += v;
    q.push(v);
  }
  T sum() { return su; }
  T top() { return q.top(); }
  void pop() {
    su -= q.top();
    q.pop();
  }
  T poll() {
    T ret = q.top();
    su -= ret;
    q.pop();
    return ret;
  }
  ll size() { return q.size(); }
};
#define pqi pq<ll>
#define pqgi pqg<ll>
// マクロ 繰り返し
// ↓@オーバーロード隔離

#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
// 逆順 閉区間
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
// ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J)                                                      \
  i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K)                                                \
  i = (j + 1 == J && k + 1 == K) ? i + 1 : i,                                  \
  j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j,                             \
  k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L)                                          \
  i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i,                    \
  j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j,               \
  k = (l + 1 == L ? (k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M)                                    \
  i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i,      \
  j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, \
  k = (l + 1 == L && m + 1 == M ? (k + 1 == K ? 0 : k + 1) : k),               \
  l = m + 1 == M ? l + 1 == L ? 0 : l + 1 : l, m = m + 1 == M ? 0 : m + 1

#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J)                                                     \
  for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K)                                               \
  for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L)                                         \
  for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I;              \
       nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M)                                  \
  for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I;  \
       nex_ind5(i, j, k, l, m, J, K, L, M))

// i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)

template <class T>
void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) {
  while (1) {
    j++;
    if (j >= J) {
      j = 0;
      i++;
      if (i < I) {
        J = (int)s[i].size();
      }
    }
    if (i >= I || J)
      return;
  }
}
template <class T>
void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K,
               vector<vector<vector<T>>> &s) {
  while (1) {
    k++;
    if (k >= K) {
      k = 0;
      j++;
      if (j >= J) {
        j = 0;
        i++;
        if (i >= I)
          return;
      }
    }
    J = (int)s[i].size();
    K = (int)s[i][j].size();
    if (J && K)
      return;
  }
}

#define repv_2(i, a) repss2(i, sz(a))
// 正方形である必要はない
// 直前を持つのとどっちが早いか
#define repv_3(i, j, a)                                                        \
  for (int I = (int)a.size(), J = (int)a[0].size(), i = 0, j = 0; i < I;       \
       nex_repv2(i, j, I, J, a))
// 箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a)                                                     \
  for (int I = (int)a.size(), J = (int)a[0].size(), K = (int)a[0][0].size(),   \
           i = 0, j = 0, k = 0;                                                \
       i < I; nex_repv3(i, j, k, I, J, K, a))
#define repv_5(i, j, k, l, a)                                                  \
  repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a)                                               \
  repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]),         \
          sz(a[0][0][0][0]))

template <typename T> struct has_rbegin_rend {
private:
  template <typename U>
  static auto check(U &&obj)
      -> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});
  static std::false_type check(...);

public:
  static constexpr bool value = decltype(check(std::declval<T>()))::value;
};
template <typename T>
constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template <typename Iterator> class Range {
public:
  Range(Iterator &&begin, Iterator &&end) noexcept
      : m_begin(std::forward<Iterator>(begin)),
        m_end(std::forward<Iterator>(end)) {}
  Iterator begin() const noexcept { return m_begin; }
  Iterator end() const noexcept { return m_end; }

private:
  const Iterator m_begin;
  const Iterator m_end;
};
template <typename Iterator>
static inline Range<Iterator> makeRange(Iterator &&begin,
                                        Iterator &&end) noexcept {
  return Range<Iterator>{std::forward<Iterator>(begin),
                         std::forward<Iterator>(end)};
}
template <typename T>
static inline decltype(auto)
makeReversedRange(const std::initializer_list<T> &iniList) noexcept {
  return makeRange(std::rbegin(iniList), std::rend(iniList));
}
template <typename T, typename std::enable_if_t<has_rbegin_rend_v<T>,
                                                std::nullptr_t> = nullptr>
static inline decltype(auto) makeReversedRange(T &&c) noexcept {
  return makeRange(std::rbegin(c), std::rend(c));
} /* rbegin(),
     rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/
template <typename T, typename std::enable_if<!has_rbegin_rend<T>::value,
                                              std::nullptr_t>::type = nullptr>
static inline void makeReversedRange(T &&) noexcept {
  static_assert(has_rbegin_rend<T>::value,
                "Specified argument doesn't have reverse iterator.");
}

#define form1(st)                                                              \
  for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form3(k, v, st)                                                        \
  for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form4(k, v, st, r)                                                     \
  for (auto &&form_it = st.begin(); form_it != st.end() && (*form_it).fi < r;  \
       ++form_it)
#define form5(k, v, st, l, r)                                                  \
  for (auto &&form_it = st.lower_bound(l);                                     \
       form_it != st.end() && (*form_it).fi < r; ++form_it)

#define fors1(st)                                                              \
  for (auto &&fors_it = st.begin(); fors_it != st.end(); ++fors_it)
#define fors2(v, st)                                                           \
  for (auto &&fors_it = st.begin(); fors_it != st.end(); ++fors_it)
#define fors3(v, st, r)                                                        \
  for (auto &&fors_it = st.begin(); fors_it != st.end() && (*fors_it) < r;     \
       ++fors_it)
#define fors4(v, st, l, r)                                                     \
  for (auto &&fors_it = st.lower_bound(l);                                     \
       fors_it != st.end() && (*fors_it) < r; ++fors_it)

#define forslr3(st, a, b)                                                      \
  for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b)                                                   \
  for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b)                                                \
  for (auto &&forslr_it = st.begin();                                          \
       forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b)                                             \
  for (auto &&forslr_it = st.lower_bound(l);                                   \
       forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)

template <class U> vector<U> to1d(vector<U> &a) { return a; }
template <class U> vector<U> to1d(vector<vector<U>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      res.push_back(a2);
  return res;
}
template <class U> vector<U> to1d(vector<vector<vector<U>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        res.push_back(a3);
  return res;
}
template <class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          res.push_back(a4);
  return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          for (auto &&a5 : a4)
            res.push_back(a5);
  return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          for (auto &&a5 : a4)
            for (auto &&a6 : a5)
              res.push_back(a6);
  return res;
}

#define fora_init_2(a, A) ;
#define fora_init_3(fora_i, a, A) auto &&a = A[fora_i];
#define fora_init_4(a, b, A, B)                                                \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];
#define fora_init_5(fora_i, a, b, A, B)                                        \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];
#define fora_init_6(a, b, c, A, B, C)                                          \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];
#define fora_init_7(fora_i, a, b, c, A, B, C)                                  \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];
#define fora_init_8(a, b, c, d, A, B, C, D)                                    \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];                                                        \
  auto &&d = D[fora_i];
#define fora_init_9(fora_i, a, b, c, d, A, B, C, D)                            \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];                                                        \
  auto &&d = D[fora_i];
#define fora_init(...)                                                         \
  over9(__VA_ARGS__, fora_init_9, fora_init_8, fora_init_7, fora_init_6,       \
        fora_init_5, fora_init_4, fora_init_3, fora_init_2)(__VA_ARGS__)

#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B)                                                \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B)                                        \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C)                                          \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C)                                  \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D)                                    \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];                                                        \
  auto &&d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D)                            \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];                                                        \
  auto &&d = D[forr_i];
#define forr_init(...)                                                         \
  over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6,       \
        forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)

#define forp_init(k, v, ...)                                                   \
  auto &&k = (*forp_it).fi;                                                    \
  auto &&v = (*forp_it).se;
#define form_init(k, v, ...)                                                   \
  auto &&k = (*form_it).fi;                                                    \
  auto &&v = (*form_it).se;
#define fors_init(v, ...) auto &&v = (*fors_it);

#define forlr_init(a, A, ngl, ngr)                                             \
  auto a = A[forlr_i];                                                         \
  auto prev = forlr_i ? A[forlr_i - 1] : ngl;                                  \
  auto next = forlr_i + 1 < rep2lim ? A[forlr_i + 1] : ngr;
#define forslr_init4(a, A, ngl, ngr)                                           \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr)                                        \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr)                                     \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init(...)                                                       \
  over6(__VA_ARGS__, forslr_init6, forslr_init5, forslr_init4)(__VA_ARGS__);

#define fora_2(a, A) for (auto &&a : A)
#define fora_3(fora_i, a, A) rep(fora_i, sz(A))
#define fora_4(a, b, A, B) rep(fora_i, sz(A))
#define fora_5(fora_i, a, b, A, B) rep(fora_i, sz(A))
#define fora_6(a, b, c, A, B, C) rep(fora_i, sz(A))
#define fora_7(fora_i, a, b, c, A, B, C) rep(fora_i, sz(A))
#define fora_8(a, b, c, d, A, B, C, D) rep(fora_i, sz(A))
#define fora_9(fora_i, a, b, c, d, A, B, C, D) rep(fora_i, sz(A))

#define forr_2(a, A) rer(forr_i, sz(A) - 1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A) - 1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)

// ↑@オーバーロード隔離

// rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
// char用のrep
#define repc(i, m, n) for (char i = m, repc3lim = n; i < repc3lim; ++i)
// i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__, reps5, reps4, reps3, reps2, )(__VA_ARGS__)
#define repss(...)                                                             \
  over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a,             \
         repss2)(__VA_ARGS__)
// vectorのindexを走査する
// repv(i,j,vvi)
#define repv(...)                                                              \
  over6(__VA_ARGS__, repv_6, repv_5, repv_4, repv_3, repv_2, )(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A) - 1; i >= 0; i--)
// repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)

#define fora(...)                                                              \
  over9(__VA_ARGS__, forr_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3,   \
        fora_2)(__VA_ARGS__)
#define forr(...)                                                              \
  over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3,   \
        forr_2)(__VA_ARGS__)

// #define forr(v, a) for(auto&& v : makeReversedRange(a))
// 参照を取らない
#define forv(a, b) for (auto a : to1d(b))

// インデックスを前後含めて走査
#define ring(i, s, len)                                                        \
  for (int i = s, prev = (s == 0) ? len - 1 : s - 1,                           \
           next = (s == len - 1) ? 0 : s + 1, cou = 0;                         \
       cou < len;                                                              \
       cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// 値と前後を見る
#define ringv(v, d)                                                            \
  index_ = 0;                                                                  \
  for (auto prev = d[sz(d) - 1], next = (int)d.size() > 1 ? d[1] : d[0],       \
            v = d[0];                                                          \
       index_ < sz(d); index_++, prev = v, v = next,                           \
            next = (index_ >= sz(d) - 1 ? d[0] : d[index_ + 1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i, sz(d))

#define form(...)                                                              \
  over5(__VA_ARGS__, form5, form4, form3, form2, form1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__, fors4, fors3, fors2, fors1)(__VA_ARGS__)
#define forslr(...)                                                            \
  over6(__VA_ARGS__, forslr6, forslr5, forslr4, forslr3)(__VA_ARGS__)
#define forp(k, v, st)                                                         \
  for (auto &&forp_it = st.begin(); forp_it != st.end(); ++forp_it)

// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const ll inf = (ll)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const dou dinf = (dou)linf * linf;
const char infc = '{';
const string infs = "{";
const double PI = 3.1415926535897932384626433832795029L;

// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()

constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの

// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
  size_t operator()(const std::pair<signed, signed> &x) const {
    return hash<ll>()(((ll)x.first << 32) | x.second);
  }
};
template <> class hash<std::pair<ll, ll>> {
public
    : /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
  size_t operator()(const std::pair<ll, ll> &x) const {
    return hash<ll>()(((ll)x.first << 32) | x.second);
  }
};
} // namespace std
// stream まとめ
/*@formatter:on*/
istream &operator>>(istream &iss, P &a) {
  iss >> a.first >> a.second;
  return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
  for (T &x : vec)
    iss >> x;
  return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
  os << p.fi << " " << p.se;
  return os;
}
ostream &operator<<(ostream &os, T p) {
  os << p.f << " " << p.s << " " << p.t;
  return os;
}
ostream &operator<<(ostream &os, F p) {
  os << p.a << " " << p.b << " " << p.c << " " << p.d;
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
  for (ll i = 0; i < vec.size(); ++i)
    os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  return os;
}

template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
  for (ll i = 0; i < vec.size(); ++i) {
    for (ll j = 0; j < vec[i].size(); ++j) {
      os << vec[i][j] << " ";
    }
    os << endl;
  }
  return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
  for (auto &&v : m)
    os << v;
  return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
  fora(v, s) { os << v << " "; }
  return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
  fora(v, a) os << v << " ";
  return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec) {
  rep(h, sz(vec)) {
    rep(w, sz(vec[0])) { os << vec[h][w]; }
    os << endl;
  }
  return os;
}
// template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>&
// a) {fora(v,a)os<<v<<endl;return os;}
/*@formatter:off*/
template <typename W, typename H> void resize(W &vec, const H head) {
  vec.resize(head);
}
template <typename W, typename H, typename... T>
void resize(W &vec, const H &head, const T... tail) {
  vec.resize(head);
  for (auto &v : vec)
    resize(v, tail...);
}
// template<typename W, typename H> void resize(vector<W> &vec, const H head) {
// vec.resize(head); } template<typename W, typename H, typename ... T> void
// resize(vector<W> &vec, const H &head, const T ... tail) {vec.resize(head);for
// (auto &v: vec)resize(v, tail...);}
template <typename T, typename F> bool all_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (!all_of2(v[i], f))
      return false;
  }
  return true;
}
template <typename T, typename F> bool any_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (any_of2(v[i], f))
      return true;
  }
  return false;
}
template <typename T, typename F> bool none_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool none_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (none_of2(v[i], f))
      return false;
  }
  return true;
}
template <typename T, typename F> bool find_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll find_if2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (find_if2(v[i], f))
      return i;
  }
  return sz(v);
}
template <typename T, typename F> bool rfind_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll rfind_if2(vector<T> &v, F f) {
  rer(i, sz(v) - 1) {
    if (rfind_if2(v[i], f))
      return i;
  }
  return -1;
}
template <class T> bool contains(string &s, const T &v) {
  return s.find(v) != string::npos;
}
template <typename T> bool contains(vector<T> &v, const T &val) {
  return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(vector<T> &v, F f) {
  return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(vector<T> &vec, F f) {
  ll ret = 0;
  fora(v, vec) ret += count_if2(v, f);
  return ret;
}
template <typename T, typename F> void for_each2(T &v, F f) { f(v); }
template <typename T, typename F> void for_each2(vector<T> &vec, F f) {
  fora(v, vec) for_each2(v, f);
}
template <typename W> ll count_od(vector<W> &a) {
  return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(vector<W> &a) {
  return count_if2(a, [](ll v) { return !(v & 1); });
}
// 削除した後のvectorを返す
template <typename T, typename F> vector<T> erase_if2(vector<T> &v, F f) {
  vector<T> nv;
  rep(i, sz(v)) {
    if (!f(v[i])) {
      nv.push_back(v[i]);
    }
  }
  return nv;
}
template <typename T, typename F>
vector<vector<T>> erase_if2(vector<vector<T>> &v, F f) {
  vector<vector<T>> res;
  rep(i, sz(v)) { res[i] = erase_if2(v[i], f); }
  return res;
}
// all_of(A, %2);
// all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a, lamr(right))
#define all_of__3(a, v, siki) all_of2(a, [&](auto v) { return siki; })
#define all_of(...) over3(__VA_ARGS__, all_of__3, all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a, f)

#define any_of__2(a, right) any_of2(a, lamr(right))
#define any_of__3(a, v, siki) any_of2(a, [&](auto v) { return siki; })
#define any_of(...) over3(__VA_ARGS__, any_of__3, any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a, f)

#define none_of__2(a, right) none_of2(a, lamr(right))
#define none_of__3(a, v, siki) none_of2(a, [&](auto v) { return siki; })
#define none_of(...) over3(__VA_ARGS__, none_of__3, none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a, f)

#define find_if__2(a, right) find_if2(a, lamr(right))
#define find_if__3(a, v, siki) find_if2(a, [&](auto v) { return siki; })
#define find_if(...) over3(__VA_ARGS__, find_if__3, find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a, f)

#define rfind_if__2(a, right) rfind_if2(a, lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a, [&](auto v) { return siki; })
#define rfind_if(...) over3(__VA_ARGS__, rfind_if__3, rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a, f)

#define contains_if__2(a, right) contains_if2(a, lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a, [&](auto v) { return siki; })
#define contains_if(...)                                                       \
  over3(__VA_ARGS__, contains_if__3, contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a, f)

#define count_if__2(a, right) count_if2(a, lamr(right))
#define count_if__3(a, v, siki) count_if2(a, [&](auto v) { return siki; })
#define count_if(...) over3(__VA_ARGS__, count_if__3, count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a, f)

#define for_each__2(a, right)                                                  \
  do {                                                                         \
    fora(v, a) { v right; }                                                    \
  } while (0)
#define for_each__3(a, v, siki)                                                \
  do {                                                                         \
    fora(v, a) { siki; }                                                       \
  } while (0)
#define for_each(...) over3(__VA_ARGS__, for_each__3, for_each__2)(__VA_ARGS__)
#define for_each_f(a, f)                                                       \
  do {                                                                         \
    fora(v, a) { f(v); }                                                       \
  } while (0)

#define erase_if__2(a, right) erase_if2(a, lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a, [&](auto v) { return siki; })
#define erase_if(...) over3(__VA_ARGS__, erase_if__3, erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a, f)

#define entry_if__2(a, right) erase_if2(a, [&](auto v) { return !(v right); })
#define entry_if__3(a, v, siki) erase_if2(a, [&](auto v) { return !(siki); })
#define entry_if(...) over3(__VA_ARGS__, entry_if__3, entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) erase_if2(a, [&](auto v) { return !f(v); })

template <class T, class U, class W> void replace(vector<W> &a, T key, U v) {
  rep(i, sz(a)) if (a[i] == key) a[i] = v;
}
template <class T, class U, class W>
void replace(vector<vector<W>> &A, T key, U v) {
  rep(i, sz(A)) replace(A[i], key, v);
}
void replace(str &a, char key, str v) {
  if (v == "")
    a.erase(remove(all(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
  rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
  rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
void replace(str &a, str key, str v) {
  stringstream t;
  ll kn = sz(key);
  std::string::size_type Pos(a.find(key));
  ll l = 0;
  while (Pos != std::string::npos) {
    t << a.substr(l, Pos - l);
    t << v;
    l = Pos + kn;
    Pos = a.find(key, Pos + kn);
  }
  t << a.substr(l, sz(a) - l);
  a = t.str();
}
template <class T> bool includes(vector<T> &a, vector<T> &b) {
  vi c = a;
  vi d = b;
  sort(all(c));
  sort(all(d));
  return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
  return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
  return next_permutation(all(a));
}
void iota(vector<ll> &ve, ll s, ll n) {
  ve.resize(n);
  iota(all(ve), s);
}
vi iota(ll s, ll len) {
  vi ve(len);
  iota(all(ve), s);
  return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
  assert(sz(a) == sz(b)); /*stringを0で初期化できない  */
  vector<pair<A, B>> res;
  rep(i, sz(a)) res.eb(a[i], b[i]);
  return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
  a.resize(sz(p)), b.resize(sz(p));
  rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
  assert(sz(a) == sz(b) && sz(b) == sz(c));
  vector<T2<A, B, C>> res;
  rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
  return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
  vector<F2<A, B, C, D>> res;
  rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
  return res;
}
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
  fisiti,
  fisitd,
  fisdti,
  fisdtd,
  fdsiti,
  fdsitd,
  fdsdti,
  fdsdtd,
  fitisi,
  fitisd,
  fitdsi,
  fitdsd,
  fdtisi,
  fdtisd,
  fdtdsi,
  fdtdsd,
  sifiti,
  sifitd,
  sifdti,
  sifdtd,
  sdfiti,
  sdfitd,
  sdfdti,
  sdfdtd,
  sitifi,
  sitifd,
  sitdfi,
  sitdfd,
  sdtifi,
  sdtifd,
  sdtdfi,
  sdfdfd,
  tifisi,
  tifisd,
  tifdsi,
  tifdsd,
  tdfisi,
  tdfisd,
  tdfdsi,
  tdfdsd,
  tisifi,
  tisifd,
  tisdfi,
  tisdfd,
  tdsifi,
  tdsifd,
  tdsdfi,
  tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
  typedef pair<A, B> U;
  if (type == fisi)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
  else if (type == fisd)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
  else if (type == fdsi)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
  else if (type == fdsd)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
  else if (type == sifi)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
  else if (type == sifd)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
  else if (type == sdfi)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
  else if (type == sdfd)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
  if (type == fisi)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
  else if (type == fisd)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
  else if (type == fdsi)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
  else if (type == fdsd)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
  else if (type == sifi)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
  else if (type == sifd)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
  else if (type == sdfi)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
  else if (type == sdfd)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
  typedef F2<A, B, C, D> U;
  if (type == fisi)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
  else if (type == fisd)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
  else if (type == fdsi)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
  else if (type == fdsd)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
  else if (type == sifi)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
  else if (type == sifd)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
  else if (type == sdfi)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
  else if (type == sdfd)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
  if (type == 0)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
    });
  else if (type == 1)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
    });
  else if (type == 2)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
    });
  else if (type == 3)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
    });
  else if (type == 4)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
    });
  else if (type == 5)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
    });
  else if (type == 6)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
    });
  else if (type == 7)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
    });
  else if (type == 8)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
    });
  else if (type == 9)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
    });
  else if (type == 10)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
    });
  else if (type == 11)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
    });
  else if (type == 12)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
    });
  else if (type == 13)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
    });
  else if (type == 14)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
    });
  else if (type == 15)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
    });
  else if (type == 16)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
    });
  else if (type == 17)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
    });
  else if (type == 18)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
    });
  else if (type == 19)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
    });
  else if (type == 20)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
    });
  else if (type == 21)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
    });
  else if (type == 22)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
    });
  else if (type == 23)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
    });
  else if (type == 24)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
    });
  else if (type == 25)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
    });
  else if (type == 26)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
    });
  else if (type == 27)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
    });
  else if (type == 28)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
    });
  else if (type == 29)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
    });
  else if (type == 30)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
    });
  else if (type == 31)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
    });
  else if (type == 32)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
    });
  else if (type == 33)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
    });
  else if (type == 34)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
    });
  else if (type == 35)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
    });
  else if (type == 36)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
    });
  else if (type == 37)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
    });
  else if (type == 38)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
    });
  else if (type == 39)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
    });
  else if (type == 40)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
    });
  else if (type == 41)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
    });
  else if (type == 42)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
    });
  else if (type == 43)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
    });
  else if (type == 44)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
    });
  else if (type == 45)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
    });
  else if (type == 46)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
    });
  else if (type == 47)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
    });
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
  typedef F2<A, B, C, D> U;
  if (type == 0)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
    });
  else if (type == 1)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
    });
  else if (type == 2)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
    });
  else if (type == 3)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
    });
  else if (type == 4)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
    });
  else if (type == 5)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
    });
  else if (type == 6)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
    });
  else if (type == 7)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
    });
  else if (type == 8)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
    });
  else if (type == 9)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
    });
  else if (type == 10)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
    });
  else if (type == 11)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
    });
  else if (type == 12)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
    });
  else if (type == 13)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
    });
  else if (type == 14)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
    });
  else if (type == 15)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
    });
  else if (type == 16)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
    });
  else if (type == 17)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
    });
  else if (type == 18)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
    });
  else if (type == 19)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
    });
  else if (type == 20)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
    });
  else if (type == 21)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
    });
  else if (type == 22)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
    });
  else if (type == 23)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
    });
  else if (type == 24)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
    });
  else if (type == 25)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
    });
  else if (type == 26)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
    });
  else if (type == 27)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
    });
  else if (type == 28)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
    });
  else if (type == 29)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
    });
  else if (type == 30)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
    });
  else if (type == 31)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
    });
  else if (type == 32)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
    });
  else if (type == 33)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
    });
  else if (type == 34)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
    });
  else if (type == 35)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
    });
  else if (type == 36)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
    });
  else if (type == 37)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
    });
  else if (type == 38)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
    });
  else if (type == 39)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
    });
  else if (type == 40)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
    });
  else if (type == 41)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
    });
  else if (type == 42)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
    });
  else if (type == 43)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
    });
  else if (type == 44)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
    });
  else if (type == 45)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
    });
  else if (type == 46)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
    });
  else if (type == 47)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
    });
}

void sort(string &a) { sort(all(a)); }
void sort(int &a, int &b) {
  if (a > b)
    swap(a, b);
}
void sort(int &a, int &b, int &c) {
  sort(a, b);
  sort(a, c);
  sort(b, c);
}
void rsort(int &a, int &b) {
  if (a < b)
    swap(a, b);
}
void rsort(int &a, int &b, int &c) {
  rsort(a, b);
  rsort(a, c);
  rsort(b, c);
}
template <class T> void sort(vector<T> &a) { sort(all(a)); }
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
  sort(all(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class T> void rsort(vector<T> &a) { sort(all(a), greater<T>()); };
template <class U, class F> void rsort(vector<U> &a, F f) {
  sort(all(a), [&](U l, U r) { return f(l) > f(r); });
};

// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
  auto c = vtop(a, b);
  sort(c);
  rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  sort(c, f);
  rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
  auto c = vtop(a, b);
  rsort(c);
  rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  rsort(c, f);
  rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
  auto d = vtot(a, b, c);
  sort(d);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  sort(d, f);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
  auto d = vtot(a, b, c);
  rsort(d);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  rsort(d, f);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  auto e = vtof(a, b, c, d);
  sort(e);
  rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  auto e = vtof(a, b, c, d);
  rsort(e);
  rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
  auto b = a;
  vi ind = iota(0, sz(a));
  sortp(b, ind);
  return ind;
} /*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
  auto b = a;
  vi ind = iota(0, sz(a));
  sortp(b, ind, f);
  return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
  return ind;
}
template <class T> vi rsorti(vector<T> &a) {
  auto b = a;
  vi ind = iota(0, sz(a));
  rsortp(b, ind);
  return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
  return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
  return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
  vi ind = iota(0, sz(a));
  auto c = a;
  auto d = b;
  sortt(c, d, ind, f);
  return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
  return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
  return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
  return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
  return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
  vi ind = iota(0, sz(a));
  auto d = vtof(a, b, c, ind);
  sort(d, f);
  rep(i, sz(a)) ind[i] = d[i].d;
  return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) {
    if (a[x] == a[y]) {
      if (b[x] == b[y])
        return c[x] < c[y];
      else
        return b[x] < b[y];
    } else {
      return a[x] < a[y];
    }
  });
  return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
  return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) {
    if (a[x] == a[y]) {
      if (b[x] == b[y])
        return c[x] > c[y];
      else
        return b[x] > b[y];
    } else {
      return a[x] > a[y];
    }
  });
  return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
  for (ll i = 0, n = a.size(); i < n; ++i)
    sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
  for (ll i = 0, n = a.size(); i < n; ++i)
    rsort(a[i]);
}

template <class... T, class U> auto sorted(U head, T... a) {
  sort(head, a...);
  return head;
}

template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
  rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
  rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
      a[i][j][k][l][m][n] = v;
}
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
  for (auto &&vx : vecc)
    fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, ll len, const T v) {
  rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, int sh, int th, int sw, int tw, T v) {
  rep(h, sh, th) rep(w, sw, tw) xx[h][w] = v;
}
template <class T, class U> void fill(vector<T> &a, vi &ind, U val) {
  fora(v, ind) a[v] = val;
}
template <class W, class T> void fill(mvec<W> &xx, const T v) {
  fora(x, xx) fill(x, v);
}

template <typename A, size_t N> A sum(A (&a)[N]) {
  A res = 0;
  rep(i, N) res += a[i];
  return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
  A res = 0;
  rep(i, N) rep(j, O) res += a[i][j];
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
      a[i][j][k][l][m][n];
  return res;
}
//@汎用便利関数 入力
ll in() {
  ll ret;
  cin >> ret;
  return ret;
}
string sin() {
  string ret;
  cin >> ret;
  return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
  cin >> head;
  in(tail...);
}

#define din1(a)                                                                \
  ll a;                                                                        \
  cin >> a
#define din2(a, b)                                                             \
  ll a, b;                                                                     \
  cin >> a >> b
#define din3(a, b, c)                                                          \
  ll a, b, c;                                                                  \
  cin >> a >> b >> c
#define din4(a, b, c, d)                                                       \
  ll a, b, c, d;                                                               \
  cin >> a >> b >> c >> d
#define din5(a, b, c, d, e)                                                    \
  ll a, b, c, d, e;                                                            \
  cin >> a >> b >> c >> d >> e
#define din6(a, b, c, d, e, f)                                                 \
  ll a, b, c, d, e, f;                                                         \
  cin >> a >> b >> c >> d >> e >> f
#define din(...)                                                               \
  over6(__VA_ARGS__, din6, din5, din4, din3, din2, din1)(__VA_ARGS__)

#define dins1(a)                                                               \
  str a;                                                                       \
  cin >> a
#define dins2(a, b)                                                            \
  str a, b;                                                                    \
  cin >> a >> b
#define dins3(a, b, c)                                                         \
  str a, b, c;                                                                 \
  cin >> a >> b >> c
#define dins4(a, b, c, d)                                                      \
  str a, b, c, d;                                                              \
  cin >> a >> b >> c >> d
#define dins5(a, b, c, d, e)                                                   \
  str a, b, c, d, e;                                                           \
  cin >> a >> b >> c >> d >> e
#define dins6(a, b, c, d, e, f)                                                \
  str a, b, c, d, e, f;                                                        \
  cin >> a >> b >> c >> d >> e >> f
#define dins(...)                                                              \
  over6(__VA_ARGS__, dins6, dins5, dins4, dins3, dins2, dins1)(__VA_ARGS__)

#define din1d(a)                                                               \
  din1(a);                                                                     \
  a--
#define din2d(a, b)                                                            \
  din2(a, b);                                                                  \
  a--, b--
#define din3d(a, b, c)                                                         \
  din3(a, b, c);                                                               \
  a--, b--, c--
#define din4d(a, b, c, d)                                                      \
  din4(a, b, c, d);                                                            \
  a--, b--, c--, d--
#define dind(...) over4(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)

template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
  cout << head << " ";
  out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
  cout << head << " ";
  out2(tail...);
  cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }

#ifdef _DEBUG
template <class T> void err2(T &&head) { cerr << head; }
template <class T, class... U> void err2(T &&head, U &&...tail) {
  cerr << head << " ";
  err2(tail...);
}
template <class T, class... U> void err(T &&head, U &&...tail) {
  cerr << head << " ";
  err2(tail...);
  cerr << "" << endl;
}
template <class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
/*@formatter:on*/
template <class T> string out_m2(vector<T> &a, ll W = inf) {
  stringstream ss;
  if (W == inf)
    W = min(sz(a), 12ll);
  if (sz(a) == 0)
    return ss.str();
  rep(i, W) {
    ss << a[i];
    if (typeid(a[i]) == typeid(P)) {
      ss << endl;
    } else {
      ss << " ";
    }
  }
  return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m2(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
  H = min({H, sz(a), 12ll});
  W = min({W, sz(a[0]), 12ll});
  stringstream ss;
  ss << endl;
  if (key == -1)
    ss << " *|";
  else
    ss << " " << key << "|";
  rep(w, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 4 + 3) ss << "_";
  ss << "" << endl;
  rep(h, H) {
    ss << std::right << std::setw(2) << h << "|";
    rep(w, min(sz(a[h]), 12ll)) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  return ss.str();
}
template <class T>
string out_m2(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf,
              ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 12;
  H = min(H, sz(a));
  rep(i, H) {
    ss << endl;
    ss << out_m2(a[i], W, U, i);
  }
  return ss.str();
}
template <class T, size_t N> string out_m2(T (&a)[N]) {
  vector<T> b;
  resize(b, N);
  rep(i, N) { b[i] = a[i]; }
  return out_m2(b);
}
template <class T, size_t N, size_t M> string out_m2(T (&a)[N][M]) {
  vector<vector<T>> b;
  resize(b, N, M);
  rep(i, N) {
    rep(j, M) { b[i][j] = a[i][j]; }
  }
  return out_m2(b);
}
template <class T, size_t N, size_t M, size_t O>
string out_m2(T (&a)[N][M][O]) {
  vector<vector<vector<T>>> b;
  resize(b, N, M, O);
  rep(i, N) {
    rep(j, M) {
      rep(k, O) { b[i][j][k] = a[i][j][k]; }
    }
  }
  return out_m2(b);
}
string out_m2(int a) {
  stringstream ss;
  ss << a;
  return ss.str();
}
/*@formatter:on*/
template <class T>
string out_m2(mvec<mvec<T>> &a, ll H = inf, ll W = inf, int key = inf) {
  H = min({H, sz(a), 6ll});
  W = min({W, sz(a[0]), 6ll});
  stringstream ss;
  ss << endl;
  //    if (key == inf)ss << " *|"; else ss << " " << key << "|";
  if (key == inf)
    ss << " *|";
  else {
    ss << std::right << std::setw(2) << key;
    ss << "|";
  }
  rep(w, -W, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 8 + 3) ss << "_";
  ss << "" << endl;
  rep(h, -H, H) {
    ss << std::right << std::setw(2) << h << "|";
    int NW = min(sz(a[h]), 6ll);
    rep(w, -NW, NW) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  return ss.str();
} /*@formatter:on*/
template <class T>
string out_m2(mvec<mvec<mvec<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 6;
  H = min(H, sz(a));
  rep(i, -H, H) {
    ss << endl;
    ss << out_m2(a[i], W, U, i);
  }
  return ss.str();
}

/*@formatter:off*/
template <class T> string out_m2(T &a) {
  stringstream ss;
  ss << a;
  return ss.str();
}
/*@formatter:on*/
template <class T> string out_m(vector<T> &a, ll W = inf) {
  stringstream ss;
  if (W == inf)
    W = min(sz(a), 12ll);
  if (sz(a) == 0)
    return ss.str();
  rep(i, W) { ss << a[i] << " "; }
  ss << "" << endl;
  return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
  H = min({H, sz(a), 12ll});
  W = min({W, sz(a[0]), 12ll});
  stringstream ss;
  ss << endl;
  if (key == -1)
    ss << " *|";
  else
    ss << " " << key << "|";
  rep(w, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 4 + 3) ss << "_";
  ss << "" << endl;
  rep(h, H) {
    ss << std::right << std::setw(2) << h << "|";
    rep(w, min(sz(a[h]), 12ll)) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  ss << endl;
  return ss.str();
}
template <class T>
string out_m(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 5;
  H = min(H, sz(a));
  rep(i, H) {
    ss << endl;
    ss << out_m(a[i], W, U, i);
  }
  ss << endl;
  return ss.str();
}
string out_m(int a) {
  stringstream ss;
  ss << a << endl;
  return ss.str();
}
template <class T> string out_m(T &a) {
  stringstream ss;
  ss << a << endl;
  return ss.str();
}
template <class T> void outv(vector<T> &a, ll W = inf) {
  cout << out_m(a, W) << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
  cout << out_m(a, H, W, key) << endl;
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
  cout << out_m(a, H, W, U) << endl;
}
#else
template <class T> void outv(vector<T> &a, ll W = inf) {
  rep(i, min(W, sz(a))) { cout << a[i] << " "; }
  cout << "" << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
  rep(i, min(H, sz(a))) { outv(a[i], W); }
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
  ;
}
#define err(...) ;
#endif
template <class T> void outl(vector<T> &a, int n = inf) {
  rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
  rep(i, sz(a)) {
    rep(j, sz(a[i])) { cout << a[i][j]; }
    cout << endl;
  }
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
template <class T> void na(vector<T> &a, ll n) {
  a.resize(n);
  rep(i, n) cin >> a[i];
}
template <class T> void na(set<T> &a, ll n) { rep(i, n) a.insert(in()); }
#define dna(a, n)                                                              \
  vi a(n);                                                                     \
  rep(dnai, n) cin >> a[dnai];
#define dnad(a, n)                                                             \
  vi a(n);                                                                     \
  rep(dnai, n) cin >> a[dnai], a[dnai]--;
template <class T> void nao(vector<T> &a, ll n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
  a.resize(n);
  rep(i, n) cin >> a[i], a[i]--;
}
template <class T> void nad(set<T> &a, ll n) { rep(i, n) a.insert(in() - 1); }
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i];
}
template <class T, class U> void na2(set<T> &a, set<U> &b, ll n) {
  rep(i, n) {
    a.insert(in());
    b.insert(in());
  }
}

#define dna2(a, b, n)                                                          \
  vi a(n), b(n);                                                               \
  rep(dna2i, n) cin >> a[dna2i] >> b[dna2i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n + 1);
  b.resize(n + 1);
  a[0] = b[0] = 0;
  rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
#define dna2d(a, b, n)                                                         \
  vi a(n), b(n);                                                               \
  rep(dna2di, n) {                                                             \
    cin >> a[dna2di] >> b[dna2di];                                             \
    a[dna2di]--, b[dna2di]--;                                                  \
  }
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n)                                                       \
  vi a(n), b(n), c(n);                                                         \
  rep(dna3i, n) cin >> a[dna3i] >> b[dna3i] >> c[dna3i];
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n)                                                      \
  vi a(n), b(n), c(n);                                                         \
  rep(dna3di, n) {                                                             \
    cin >> a[dna3di] >> b[dna3di] >> c[dna3di];                                \
    a[dna3di]--, b[dna3di]--, c[dna3di]--;                                     \
  }
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  d.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n)                                                    \
  vi a(n), b(n), c(n), d(n);                                                   \
  rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i];
#define dna4d(a, b, c, d, n)                                                   \
  vi a(n), b(n), c(n), d(n);                                                   \
  rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i],           \
      --a[dna4i], --b[dna4i], --c[dna4i], --d[dna4i];
#define nt(a, h, w)                                                            \
  resize(a, h, w);                                                             \
  rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w)                                                           \
  resize(a, h, w);                                                             \
  rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w)                                                           \
  resize(a, h + 2, w + 2);                                                     \
  fill(a, '#');                                                                \
  rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
// デバッグ
#define sp << " " <<

#define deb1(x) debugName(x) << " = " << out_m2(x)
#define deb_2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) << ", " << deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) << ", " << deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb_4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
#define deb7(x, ...) deb1(x) << ", " << deb6(__VA_ARGS__)
#define deb8(x, ...) deb1(x) << ", " << deb7(__VA_ARGS__)
#define deb9(x, ...) deb1(x) << ", " << deb8(__VA_ARGS__)
#define deb10(x, ...) deb1(x) << ", " << deb9(__VA_ARGS__)

#ifdef _DEBUG
#define deb(...)                                                               \
  cerr << over10(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb_4,      \
                 deb_3, deb_2, deb1)(__VA_ARGS__)                              \
       << endl

#define base_keta 8
void print_n_base(int x, int base) { cerr << bitset<base_keta>(x) << endl; }
template <class T> void print_n_base(vector<T> X, int base) {
  cerr << endl;
  for (auto &&x : X) {
    print_n_base(x, base);
  }
  cerr << endl;
}

// n進数
#define deb2(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 2);
#define deb3(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 3);
#define deb4(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 4);

#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#endif

#define debugline(x)                                                           \
  cerr << x << " "                                                             \
       << "(L:" << __LINE__ << ")" << '\n'

//@formatter:off
// よく使うクラス、構造体
// graphでredefineしているため、書き換えたら向こうも書き換える
struct unionfind {
  vector<ll> par;
  vector<ll> siz;
  vector<ll> es;
  ll n, trees; // 連結グループの数(親の種類)
  unionfind(ll n) : n(n), trees(n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
  }
  ll root(ll x) {
    if (par[x] == x) {
      return x;
    } else {
      return par[x] = root(par[x]);
    }
  }
  ll operator()(ll x) { return root(x); }
  bool unite(ll x, ll y) {
    x = root(x);
    y = root(y);
    es[x]++;
    if (x == y)
      return false;
    if (siz[x] > siz[y])
      swap(x, y);
    trees--;
    par[x] = y;
    siz[y] += siz[x];
    es[y] += es[x];
    return true;
  }
  bool same(ll x, ll y) { return root(x) == root(y); }
  ll size(ll x) { return siz[root(x)]; }
  ll esize(ll x) { return es[root(x)]; }
  vi sizes() {
    vi cou(n);
    vi ret;
    ret.reserve(n);
    rep(i, n) { cou[root(i)]++; }
    rep(i, n) {
      if (cou[i])
        ret.push_back(cou[i]);
    }
    return ret;
  }
  // つながりを無向グラフと見なし、xが閉路に含まれるか判定
  bool close(ll x) { return esize(x) >= size(x); }
  vector<vi> sets() {
    vi ind(n, -1);
    ll i = 0;
    vvi(res, trees);
    rep(j, n) {
      ll r = root(j);
      if (ind[r] == -1)
        ind[r] = i++;
      res[ind[r]].push_back(j);
    }
    rep(i, trees) {
      ll r = root(res[i][0]);
      if (res[i][0] == r)
        continue;
      rep(j, 1, sz(res[i])) {
        if (res[i][j] == r) {
          swap(res[i][0], res[i][j]);
          break;
        }
      }
    }
    return res;
  }
}; //@formatter:off

using bll = __int128;
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;

std::ostream &operator<<(std::ostream &dest, __int128_t value) {
  std::ostream::sentry s(dest);
  if (s) {
    __uint128_t tmp = value < 0 ? -value : value;
    char buffer[128];
    char *d = std::end(buffer);
    do {
      --d;
      *d = "0123456789"[tmp % 10];
      tmp /= 10;
    } while (tmp != 0);
    if (value < 0) {
      --d;
      *d = '-';
    }
    ll len = std::end(buffer) - d;
    if (dest.rdbuf()->sputn(d, len) != len) {
      dest.setstate(std::ios_base::badbit);
    }
  }
  return dest;
}
//__int128 toi128(string &s) {    __int128 ret = 0;    for (ll i = 0; i <
//s.length(); ++i)        if ('0' <= s[i] && s[i] <= '9')            ret = 10 *
//ret + s[i] - '0';    return ret;}

// エラー
void ole() {
#ifdef _DEBUG
  debugline("ole");
  exit(0);
#endif
  string a = "a";
  rep(i, 30) a += a;
  rep(i, 1 << 17) cout << a << endl;
  cout << "OLE 出力長制限超過" << endl;
  exit(0);
}
void re() {
  assert(0 == 1);
  exit(0);
}
void tle() {
  while (inf)
    cout << inf << endl;
}

// 便利関数

// テスト用
#define rand xor128_
unsigned long xor128_(void) {
  static unsigned long x = 123456789, y = 362436069, z = 521288629,
                       w = 88675123;
  unsigned long t;
  t = (x ^ (x << 11));
  x = y;
  y = z;
  z = w;
  return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
  assert(min <= max);
  if (min >= 0 && max >= 0) {
    return rand() % (max + 1 - min) + min;
  } else if (max < 0) {
    return -rand(-max, -min);
  } else {
    if (rand() % 2) {
      return rand(0, max);
    } else {
      return -rand(0, -min);
    }
  }
}
ll rand(ll max) { return rand(0, max); }
vi ranv(ll n, ll min, ll max) {
  vi v(n);
  rep(i, n) v[i] = rand(min, max);
  return v;
}
str ransu(ll n) {
  str s;
  rep(i, n) s += (char)rand('A', 'Z');
  return s;
}
str ransl(ll n) {
  str s;
  rep(i, n) s += (char)rand('a', 'z');
  return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
  vi v(n);
  bool bad = 1;
  while (bad) {
    bad = 0;
    v.resize(n);
    rep(i, n) {
      if (i && min > max - v[i - 1]) {
        bad = 1;
        break;
      }
      if (i)
        v[i] = v[i - 1] + rand(min, max - v[i - 1]);
      else
        v[i] = rand(min, max);
    }
  }
  return v;
}
// 便利 汎用

void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
  l.resize(n);
  r.resize(n);
  rep(i, n) {
    l[i] = rand(min, max);
    r[i] = l[i] + rand(0, max - l[i]);
  }
}
template <class T> vector<pair<T, int>> run_length(vector<T> &a) {
  vector<pair<T, int>> ret;
  ret.eb(a[0], 1);
  rep(i, 1, sz(a)) {
    if (ret.back().fi == a[i]) {
      ret.back().se++;
    } else {
      ret.eb(a[i], 1);
    }
  }
  return ret;
}
vector<pair<char, ll>> run_length(string &a) {
  vector<pair<char, ll>> ret;
  ret.eb(a[0], 1);
  rep(i, 1, sz(a)) {
    if (ret.back().fi == a[i]) {
      ret.back().se++;
    } else {
      ret.eb(a[i], 1);
    }
  }
  return ret;
}
template <class F> ll mgr(ll ok, ll ng, F f) {
  bool han = true;
  if (ok < ng)
    while (ng - ok > 1) {
      ll mid = (ok + ng) >> 1;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  else
    while (ok - ng > 1) {
      ll mid = (ok + ng) >> 1;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  return ok;
}
template <class F> dou mgrd(dou ok, dou ng, F f, int kai = 100) {
  bool han = true;
  if (ok < ng)
    rep(i, kai) {
      dou mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  else
    rep(i, kai) {
      dou mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  return ok;
}
// strを整数として比較
string smax(str &a, str b) {
  if (sz(a) < sz(b)) {
    return b;
  } else if (sz(a) > sz(b)) {
    return a;
  } else if (a < b)
    return b;
  else
    return a;
}
// strを整数として比較
string smin(str &a, str b) {
  if (sz(a) > sz(b)) {
    return b;
  } else if (sz(a) < sz(b)) {
    return a;
  } else if (a > b)
    return b;
  else
    return a;
}
// エラー-1
template <typename W, typename T> ll find(vector<W> &a, int l, const T key) {
  rep(i, l, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
  rep(i, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
  rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
  return mp(-1, -1);
}
template <typename W, typename U>
T find(vector<vector<vector<W>>> &a, const U key) {
  rep(i, sz(a)) rep(j, sz(a[0]))
      rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
  return mt(-1, -1, -1);
}
// stringも書く
int find(string &s, const string key) {
  int klen = sz(key);
  rep(i, sz(s) - klen + 1) {
    if (s[i] != key[0])
      continue;
    if (s.substr(i, klen) == key) {
      return i;
    }
  }
  return -1;
}
int find(string &s, int l, const string key) {
  int klen = sz(key);
  rep(i, l, sz(s) - klen + 1) {
    if (s[i] != key[0])
      continue;
    if (s.substr(i, klen) == key) {
      return i;
    }
  }
  return -1;
}
int find(string &s, const char key) {
  rep(i, sz(s)) {
    if (s[i] == key)
      return i;
  }
  return -1;
}
int find(string &s, int l, const char key) {
  rep(i, l, sz(s)) {
    if (s[i] == key)
      return i;
  }
  return -1;
}
template <typename W, typename T> ll count2(W &a, const T k) { return a == k; }
template <typename W, typename T> ll count2(vector<W> &a, const T k) {
  ll ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
template <typename W, typename T> ll count(vector<W> &a, const T k) {
  ll ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
vi count(vi &a) {
  int ma = 0;
  fora(v, a) {
    if (ma < v)
      ma = v;
  }
  vi res(ma + 1);
  fora(v, a) { res[v]++; }
  return res;
}
ll count(str &a, str k) {
  ll ret = 0, len = k.length();
  auto pos = a.find(k);
  while (pos != string::npos)
    pos = a.find(k, pos + len), ++ret;
  return ret;
}
vi count(str &a) {
  vi cou(26);
  char c = 'a';
  if ('A' <= a[0] && a[0] <= 'Z')
    c = 'A';
  rep(i, sz(a))++ cou[a[i] - c];
  return cou;
}
#define couif count_if
// algorythm

ll rev(ll a) {
  ll res = 0;
  while (a) {
    res *= 10;
    res += a % 10;
    a /= 10;
  }
  return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class U> void rev(vector<vector<U>> &a) {
  vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
  rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
  a = b;
}
void rev(string &a) { reverse(all(a)); }
constexpr ll p10[] = {1,
                      10,
                      100,
                      1000,
                      10000,
                      100000,
                      1000000,
                      10000000,
                      100000000,
                      1000000000,
                      10000000000ll,
                      100000000000ll,
                      1000000000000ll,
                      10000000000000ll,
                      100000000000000ll,
                      1000000000000000ll,
                      10000000000000000ll,
                      100000000000000000ll,
                      1000000000000000000ll};

// 0は0桁
ll keta(ll v) {
  if (v < p10[9]) {
    if (v < p10[4]) {
      if (v < p10[2]) {
        if (v < p10[1]) {
          if (v < p10[0])
            return 0;
          else
            return 1;
        } else
          return 2;
      } else {
        if (v < p10[3])
          return 3;
        else
          return 4;
      }
    } else {
      if (v < p10[7]) {
        if (v < p10[5])
          return 5;
        else if (v < p10[6])
          return 6;
        else
          return 7;
      } else {
        if (v < p10[8])
          return 8;
        else
          return 9;
      }
    }
  } else {
    if (v < p10[13]) {
      if (v < p10[11]) {
        if (v < p10[10])
          return 10;
        else
          return 11;
      } else {
        if (v < p10[12])
          return 12;
        else
          return 13;
      }
    } else {
      if (v < p10[15]) {
        if (v < p10[14])
          return 14;
        else
          return 15;
      } else {
        if (v < p10[17]) {
          if (v < p10[16])
            return 16;
          else
            return 17;
        } else {
          if (v < p10[18])
            return 18;
          else
            return 19;
        }
      }
    }
  }
}
ll getr(ll a, ll keta) { return (a / (ll)pow(10, keta)) % 10; }
// 上から何桁目か
ll getl(ll a, ll ket) {
  int sketa = keta(a);
  return getr(a, sketa - 1 - ket);
}
ll dsum(ll v, ll sin = 10) {
  ll ret = 0;
  for (; v; v /= sin)
    ret += v % sin;
  return ret;
}

ll mask10(ll v) { return p10[v] - 1; }
// 変換系
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
template <class T> auto keys(T &a) {
  vector<decltype((a.begin())->fi)> res;
  for (auto &&k : a)
    res.push_back(k.fi);
  return res;
}
template <class T> auto values(T &a) {
  vector<decltype((a.begin())->se)> res;
  for (auto &&k : a)
    res.push_back(k.se);
  return res;
}
template <class T, class U> bool chma(T &a, const U &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <class T> constexpr T min(T a, signed b) { return a < b ? a : b; }
template <class T> constexpr T max(T a, signed b) { return a < b ? b : a; }
template <class T> constexpr T min(T a, T b, T c) {
  return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> constexpr T max(T a, T b, T c) {
  return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> T min(vector<T> &a) { return *min_element(all(a)); }
template <class T> T mini(vector<T> &a) {
  return min_element(all(a)) - a.begin();
}
template <class T> T min(vector<T> &a, ll n) {
  return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T min(vector<T> &a, ll s, ll n) {
  return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a) { return *max_element(all(a)); }
template <class T, class U> T max(vector<T> &a, vector<U> &b) {
  return max(*max_element(all(a)), *max_element(all(b)));
}
template <class T> T maxi(vector<T> &a) {
  return max_element(all(a)) - a.begin();
}
template <class T> T max(vector<T> &a, ll n) {
  return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a, ll s, ll n) {
  return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> A max(A (&a)[N]) {
  A res = a[0];
  rep(i, N) res = max(res, a[i]);
  return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
  A res = a[0];
  rep(i, N) res = min(res, a[i]);
  return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <class T> T sum(vector<T> &v, ll s, ll t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += v[i];
  return ret;
}
template <class T> T sum(vector<T> &v, ll t = inf) { return sum(v, 0, t); }
template <class T> T sum(vector<vector<T>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<T>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T> T sum(vector<vector<vector<T>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T>
T sum(vector<vector<vector<vector<vector<T>>>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T>
T sum(vector<vector<vector<vector<vector<T>>>>> &v, int t = inf) {
  return sum(v, 0, t);
}

template <class T> auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
  auto q = r;
  T ret = 0;
  while (sz(q)) {
    ret += q.top();
    q.pop();
  }
  return ret;
}
template <class T> auto sum(priority_queue<T> &r) {
  auto q = r;
  T ret = 0;
  while (sz(q)) {
    ret += q.top();
    q.pop();
  }
  return ret;
}
// template<class T, class U, class... W>  auto sumn(vector<T> &v, U head, W...
// tail) {    auto ret = sum(v[0], tail...);    rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...);    return ret;}
vi v_i(vi &a) {
  int n = max(a) + 1;
  vi ret(n, -1);
  rep(i, sz(a)) { ret[a[i]] = i; }
  return ret;
}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
template <class T> void clear(queue<T> &q) {
  while (q.size())
    q.pop();
}
template <class T> T *negarr(ll size) {
  T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
  return body + size;
}
template <class T> T *negarr2(ll h, ll w) {
  double **dummy1 = new double *[2 * h + 1];
  double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
  dummy1[0] = dummy2 + w;
  for (ll i = 1; i <= 2 * h + 1; ++i) {
    dummy1[i] = dummy1[i - 1] + 2 * w + 1;
  }
  double **a = dummy1 + h;
  return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
  return ret;
}
// kと同じものの数
template <class T, class U> vi imo(vector<T> &a, U k) {
  vector<T> ret = a;
  rep(i, sz(ret)) ret[i] = a[i] == k;
  rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
  return ret;
}
template <class T> vector<T> imox(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
  return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
  return ret;
}
template <class T> vector<T> ima(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) chma(ret[i + 1], ret[i]);
  return ret;
}
// template<class T> vector<T> rimi(vector<T> &v) {    vector<T> ret = v; rer(i,
// sz(ret) - 1, 1)chmi(ret[i - 1], ret[i]);    return ret;} template<class T>
// vector<T> rima(vector<T> &v) {    vector<T> ret = v;    rer(i, sz(ret) - 1,
// 1)chma(ret[i - 1], ret[i]);    return ret;}
template <class T> struct ruiC {
  vector<T> rui;
  ruiC(vector<T> &ru) : rui(ru) {}
  /*先頭0*/
  ruiC() : rui(1, 0) {}
  T operator()(ll l, ll r) {
    if (l > r) {
      cerr << "ruic ";
      deb(l, r);
      assert(0);
    }
    return rui[r] - rui[l];
  }
  T operator()(int r) { return operator()(0, r); }
  /*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
  /*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
  //    T operator[](ll i) { return rui[i + 1] - rui[i]; }
  T operator[](ll i) { return rui[i]; }
  /*0から順に追加される必要がある*/
  void operator+=(T v) { rui.push_back(rui.back() + v); }
  void add(int i, T v) {
    if (sz(rui) - 1 != i)
      ole();
    operator+=(v);
  }
  T back() { return rui.back(); }
  ll size() { return rui.size(); }
  auto begin() { return rui.begin(); }
  auto end() { return rui.end(); }
};
template <class T> struct ruimax {
  template <typename Monoid> struct SegmentTree { /*pairで処理*/
    int sz;
    vector<Monoid> seg;
    const Monoid M1 = mp(MIN(T), -1);
    Monoid f(Monoid a, Monoid b) { return max(a, b); }
    void build(vector<T> &a) {
      int n = sz(a);
      sz = 1;
      while (sz < n)
        sz <<= 1;
      seg.assign(2 * sz, M1);
      rep(i, n) { seg[i + sz] = mp(a[i], i); }
      for (int k = sz - 1; k > 0; k--) {
        seg[k] = f(seg[k << 1], seg[(k << 1) | 1]);
      }
    }
    Monoid query(int a, int b) {
      Monoid L = M1, R = M1;
      for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
        if (a & 1)
          L = f(L, seg[a++]);
        if (b & 1)
          R = f(seg[--b], R);
      }
      return f(L, R);
    }
    Monoid operator[](const int &k) const { return seg[k + sz]; }
  };

private:
  vector<T> ve;
  SegmentTree<pair<T, int>> seg;
  vector<T> rv;
  vector<T> ri;
  bool build = false;

public:
  int n;
  ruimax(vector<T> &a) : ve(a), n(sz(a)) {
    int index = -1;
    int ma = MIN(T);
    rv.resize(n + 1);
    ri.resize(n + 1);
    rv[0] = -linf;
    ri[0] = -1;
    rep(i, n) {
      if (chma(ma, a[i])) {
        index = i;
      }
      rv[i + 1] = ma;
      ri[i + 1] = index;
    }
  }
  T operator()(int l, int r) {
    if (!(l <= r && 0 <= l && r <= n)) {
      deb(l, r, n);
      assert(0);
    }
    if (l == 0) {
      return rv[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).first;
    }
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  T getv(int l, int r) { return operator()(l, r); }
  T geti(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return ri[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).second;
    }
  }
  T geti(int r = inf) { return geti(0, min(r, n)); };
  T getv(int r = inf) { return getv(0, min(r, n)); };
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};
template <class T> struct ruimin {
  template <typename Monoid> struct SegmentTree { /*pairで処理*/
    int sz;
    vector<Monoid> seg;
    const Monoid M1 = mp(MAX(T), -1);
    Monoid f(Monoid a, Monoid b) { return min(a, b); }
    void build(vector<T> &a) {
      int n = sz(a);
      sz = 1;
      while (sz < n)
        sz <<= 1;
      seg.assign(2 * sz, M1);
      rep(i, n) { seg[i + sz] = mp(a[i], i); }
      for (int k = sz - 1; k > 0; k--) {
        seg[k] = f(seg[k << 1], seg[(k << 1) | 1]);
      }
    }
    Monoid query(int a, int b) {
      Monoid L = M1, R = M1;
      for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
        if (a & 1)
          L = f(L, seg[a++]);
        if (b & 1)
          R = f(seg[--b], R);
      }
      return f(L, R);
    }
    Monoid operator[](const int &k) const { return seg[k + sz]; }
  };

private:
  vector<T> ve;
  SegmentTree<pair<T, int>> seg;
  vector<T> rv;
  vector<T> ri;
  bool build = false;
  int n;

public:
  ruimin(vector<T> &a) : ve(a), n(sz(a)) {
    int index = -1;
    int mi = MAX(T);
    rv.resize(n + 1);
    ri.resize(n + 1);
    rv[0] = linf;
    ri[0] = -1;
    rep(i, n) {
      if (chmi(mi, a[i])) {
        index = i;
      }
      rv[i + 1] = mi;
      ri[i + 1] = index;
    }
  }
  T operator()(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return rv[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).first;
    }
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  T getv(int l, int r) { return operator()(l, r); }
  T geti(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return ri[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).second;
    }
  }
  T geti(int r = inf) { return geti(0, min(r, n)); };
  T getv(int r = inf) { return getv(0, min(r, n)); };
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};

template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
  fora(v, a.rui) os << v << " ";
  return os;
}
template <class T> vector<T> ruiv(vector<T> &a) {
  vector<T> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
  return ret;
}
template <class T> ruiC<T> ruic() { return ruiC<T>(); }
template <class T> ruiC<T> ruic(vector<T> &a) {
  vector<T> ret = ruiv(a);
  return ruiC<T>(ret);
}
vvi() ruib(vi &a) {
  vvi(res, 61, sz(a) + 1);
  rep(k, 61) {
    rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }
  }
  return res;
}
vector<ruiC<int>> ruibc(vi &a) {
  vector<ruiC<int>> ret(61);
  vvi(res, 61, sz(a));
  rep(k, 61) {
    rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; }
    ret[k] = ruic(res[k]);
  }
  return ret;
}
vector<ll> ruiv(string &a) {
  if (sz(a) == 0)
    return vi(1);
  ll dec = ('0' <= a[0] && a[0] <= '9') ? '0' : 0;
  vector<ll> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + a[i] - dec;
  return ret;
}
ruiC<ll> ruic(string &a) {
  vector<ll> ret = ruiv(a);
  return ruiC<ll>(ret);
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
  vi ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
  return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
  vi ret = ruiv(a, k);
  return ruiC<ll>(ret);
}

// h query
template <class T> vector<T> imoh(vector<vector<T>> &v, int w) {
  vector<T> ret(sz(v));
  rep(h, sz(ret)) { ret[h] = v[h][w]; }
  rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; }
  return ret;
}
template <class T> vector<T> ruih(vector<vector<T>> &v, int w) {
  vector<T> ret(sz(v) + 1);
  rep(h, sz(v)) { ret[h + 1] = v[h][w]; }
  rep(i, sz(v)) { ret[i + 1] += ret[i]; }
  return ret;
}
template <class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) {
  vector<T> ret = ruih(a, w);
  return ruiC<T>(ret);
}

// xor
template <class T> struct ruixC {
  vector<T> rui;
  ruixC(vector<T> &ru) : rui(ru) {}
  T operator()(ll l, ll r) {
    if (l > r) {
      cerr << "ruiXc ";
      deb(l, r);
      assert(0);
    }
    return rui[r] ^ rui[l];
  }
  T operator[](ll i) { return rui[i]; }
  T back() { return rui.back(); }
  ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
  vector<T> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
  return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
  vi ret = ruix(a);
  return ruixC<ll>(ret);
}
template <class T> vector<T> ruim(vector<T> &a) {
  vector<T> res(a.size() + 1, 1);
  rep(i, a.size()) res[i + 1] = res[i] * a[i];
  return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
  ll n = sz(a);
  vector<T> ret(n + 1);
  rep(i, 1, n) {
    ret[i] = a[i - 1];
    chmi(ret[i + 1], ret[i]);
  }
  return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> struct rruiC {
  vector<T> rui;
  int n;
  rruiC(vector<T> &a) : n(sz(a)) {
    rui.resize(n + 1);
    rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; }
  }
  /*[r l)*/
  T operator()(int r, int l) {
    r++;
    l++;
    assert(l <= r && l >= 0 && r <= n);
    return rui[l] - rui[r];
  }
  T operator()(int l) { return operator()(n - 1, l); }
  T operator[](int i) { return operator()(i); }
};
template <class T> ostream &operator<<(ostream &os, rruiC<T> a) {
  fora(v, a.rui) os << v << " ";
  return os;
}

#define rrui rruic
template <class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }

// 掛け算
template <class T> struct ruimulC {
  vector<T> rv;
  int n;
  ruimulC(vector<T> &a) : rv(a), n(sz(a)) {
    rv.resize(n + 1);
    rv[0] = 1;
    rep(i, n) { rv[i + 1] = a[i] * rv[i]; }
  }
  ruimulC() : n(0) {
    rv.resize(n + 1);
    rv[0] = 1;
  }
  void operator+=(T v) {
    rv.push_back(rv.back() * v);
    n++;
  }
  T operator()(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    return rv[r] / rv[l];
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};
template <class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template <class T> ruimulC<T> ruimul() {
  vector<T> a;
  return ruimulC<T>(a);
}
/*@formatter:off*/
template <class T> T *rruim(vector<T> &a) {
  ll len = a.size();
  T *body = (T *)malloc((len + 1) * sizeof(T));
  T *res = body + 1;
  res[len - 1] = 1;
  rer(i, len - 1) res[i - 1] = res[i] * a[i];
  return res;
}
template <class T, class U> void inc(pair<T, U> &a, U v = 1) {
  a.first += v, a.second += v;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
  for (auto &u : a)
    inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, W v = 1) {
  for (auto &u : a)
    dec(u, v);
  for (auto &u : b)
    dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
  for (auto &u : a)
    dec(u, 1);
  for (auto &u : b)
    dec(u, 1);
  for (auto &u : c)
    dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool ins(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
  return ins(0, i, sz(a)) && ins(0, j, sz(a));
}
#define inside ins
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(vector<T> &a) {
  vector<T> ret = a;
  fora(v, ret) v = u(v);
  return ret;
}

// 添え字を返す
template <class F> ll goldd_l(ll left, ll right, F calc) {
  double GRATIO = 1.6180339887498948482045868343656;
  ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
  ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
  ll fl = calc(lm);
  ll fr = calc(rm);
  while (right - left > 10) {
    if (fl < fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + (ll)((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  ll minScore = MAX(ll);
  ll resIndex = left;
  for (ll i = left; i < right + 1; ++i) {
    ll score = calc(i);
    if (minScore > score) {
      minScore = score;
      resIndex = i;
    }
  }
  return resIndex;
}
template <class F> ll goldt_l(ll left, ll right, F calc) {
  double GRATIO = 1.6180339887498948482045868343656;
  ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
  ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
  ll fl = calc(lm);
  ll fr = calc(rm);
  while (right - left > 10) {
    if (fl > fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + (ll)((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  if (left > right) {
    ll l = left;
    left = right;
    right = l;
  }
  ll maxScore = MIN(ll);
  ll resIndex = left;
  for (ll i = left; i < right + 1; ++i) {
    ll score = calc(i);
    if (maxScore < score) {
      maxScore = score;
      resIndex = i;
    }
  }
  return resIndex;
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> dou goldd_d(dou left, dou right, F calc, ll loop = 200) {
  dou GRATIO = 1.6180339887498948482045868343656;
  dou lm = left + ((right - left) / (GRATIO + 1.0));
  dou rm = lm + ((right - lm) / (GRATIO + 1.0));
  dou fl = calc(lm);
  dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
  ll k = 141;
  loop++;
  while (--loop) {
    if (fl < fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + ((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + ((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  return left;
}
template <class F> dou goldt_d(dou left, dou right, F calc, ll loop = 200) {
  double GRATIO = 1.6180339887498948482045868343656;
  dou lm = left + ((right - left) / (GRATIO + 1.0));
  dou rm = lm + ((right - lm) / (GRATIO + 1.0));
  dou fl = calc(lm);
  dou fr = calc(rm);
  loop++;
  while (--loop) {
    if (fl > fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + ((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + ((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  return left;
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> ll goldd_ls(ll l, ll r, F calc, ll time = 2000) {
  auto lim = milliseconds(time - 20);
  ll mini = 0, minv = MAX(ll); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
    ll nl = l;
    ll nr = l + haba;
    rep(i, k) {
      ll ni = goldd_l(nl, nr, calc);
      if (chmi(minv, calc(ni)))
        mini = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return mini;
}
template <class F> ll goldt_ls(ll l, ll r, F calc, ll time = 2000) {
  auto lim = milliseconds(time - 20);
  ll maxi = 0, maxv = MIN(ll); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
    ll nl = l;
    ll nr = l + haba;
    rep(i, k) {
      ll ni = goldt_l(nl, nr, calc);
      if (chma(maxv, calc(ni)))
        maxi = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return maxi;
}
template <class F>
dou goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
  auto lim = milliseconds(time - 20);
  dou mini = 0, minv = MAX(dou); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    dou haba = (r - l) / k;
    dou nl = l;
    dou nr = l + haba;
    rep(i, k) {
      dou ni = goldd_d(nl, nr, calc);
      if (chmi(minv, calc(ni)))
        mini = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return mini;
}
template <class F>
dou goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
  auto lim = milliseconds(time - 20);
  dou maxi = 0, maxv = MIN(dou); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    dou haba = (r - l) / k;
    dou nl = l;
    dou nr = l + haba;
    rep(i, k) {
      dou ni = goldt_d(nl, nr, calc);
      if (chma(maxv, calc(ni)))
        maxi = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return maxi;
}
template <class T> T min(vector<vector<T>> &a) {
  T res = MAX(T);
  rep(i, a.size()) chmi(res, *min_element(all(a[i])));
  return res;
}
template <class T> T max(vector<vector<T>> &a) {
  T res = MIN(T);
  rep(i, a.size()) chma(res, *max_element(all(a[i])));
  return res;
}
#ifdef _DEBUG
auto pow(int a, int k) {
  static bool was = 1;
  if (was) {
    message += "if integer use *powi* it's very fast\n";
  }
  was = 0;
  return std::pow(a, k);
}
auto pow(signed a, int k) { return pow((int)a, k); }
auto pow(signed a, signed k) { return pow((int)a, (int)k); }
#endif
// 整数型のpow
int powi(int a, int k) {
  if (a == 2)
    return 1ll << k;
  int res = 1;
  int x = a;
  while (k) {
    res *= (k & 1) * x;
    x *= x;
    k >>= 1;
  }
  return res;
}
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
  assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
  return (m >> keta) & 1;
}
// bget(n)次元
//                           NならN-1まで
vector<vi> bget2(vi &a, int keta_size) {
  vvi(res, keta_size, sz(a));
  rep(k, keta_size) {
    rep(i, sz(a)) { res[k][i] = bget(a[i], k); }
  }
  return res;
}
vi bget1(vi &a, int keta) {
  vi res(sz(a));
  rep(i, sz(a)) { res[i] = bget(a[i], keta); }
  return res;
}
ll bget(ll m, ll keta, ll sinsuu) {
  m /= (ll)pow(sinsuu, keta);
  return m % sinsuu;
}
constexpr ll bit(ll n) {
#ifdef _DEBUG
  assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
  return (1LL << (n));
}
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
//{0, 2} -> 101
ll bit(vi &a) {
  int m = 0;
  for (auto &&v : a)
    m |= bit(v);
  return m;
}

//{1, 1, 0} -> 011
// bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bitb(vi &a) {
  int m = 0;
  rep(i, sz(a)) if (a[i]) m |= bit(i);
  return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) { return n & -n; }
ll lbiti(ll n) { return log2(n & -n); }
// 最上位ビット
ll hbit(ll n) {
  n |= (n >> 1);
  n |= (n >> 2);
  n |= (n >> 4);
  n |= (n >> 8);
  n |= (n >> 16);
  n |= (n >> 32);
  return n - (n >> 1);
}
ll hbiti(ll n) { return log2(hbit(n)); }
ll hbitk(ll n) {
  ll k = 0;
  rer(i, 5) {
    ll a = k + (1ll << i);
    ll b = 1ll << a;
    if (b <= n)
      k += 1ll << i;
  }
  return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
  if (!mask)
    return mask = (1LL << r) - 1;
  ll x = mask & -mask; /*最下位の1*/
  ll y = mask + x;     /*連続した下の1を繰り上がらせる*/
  ll res = ((mask & ~y) / x >> 1) | y;
  if (bget(res, n))
    return mask = 0;
  else
    return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
  vi res;
  ll m = 0;
  while (nextComb(m, n, r)) {
    res.push_back(m);
  }
  return res;
}
// masの立ってるindexを見る
#define forbit(i, mas)                                                         \
  for (int forbitj = lbit(mas), forbitm = mas, i = log2(forbitj); forbitm;     \
       forbitm = forbitj ? forbitm ^ forbitj : 0, forbitj = lbit(forbitm),     \
           i = log2(forbitj))

char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
  if ('A' <= c && c <= 'Z')
    return c - 'A';
  return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
  ll res = 0;
  if (sz(v) > 18) {
    debugline("vtoi");
    deb(sz(v));
    ole();
  }
  rep(i, sz(v)) {
    res *= 10;
    res += v[i];
  }
  return res;
}
vi itov(ll i) {
  vi res;
  while (i) {
    res.push_back(i % 10);
    i /= 10;
  }
  rev(res);
  return res;
}
vi stov(string &a) {
  ll n = sz(a);
  vi ret(n);
  rep(i, n) { ret[i] = a[i] - '0'; }
  return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
  ll n = sz(a);
  vi ret(n);
  rep(i, n) ret[i] = a[i] == one;
  return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
  ll n = sz(s), m = sz(s[0]);
  vector<vector<ll>> res(n, vector<ll>(m));
  rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
  return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
  vi b;
  ll len = a.size();
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, umap<ll, ll> &map) {
  vi b;
  ll len = a.size();
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    ll v = a[i];
    a[i] = lower_bound(all(b), a[i]) - b.begin();
    map[v] = a[i];
  }
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r) {
  vi b;
  ll len = a.size();
  fora(v, a) b.push_back(v);
  fora(v, r) b.push_back(v);
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (ll i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r, vi &s) {
  vi b;
  ll len = a.size();
  fora(v, a) b.push_back(v);
  fora(v, r) b.push_back(v);
  fora(v, s) b.push_back(v);
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (ll i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  for (ll i = 0; i < sz(s); ++i)
    r[i] = lower_bound(all(b), s[i]) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vector<vi> &a) {
  vi b;
  fora(vv, a) fora(v, vv) b.push_back(v);
  sort(b);
  unique(b);
  fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vector<vector<vi>> &a) {
  vi b;
  fora(vvv, a) fora(vv, vvv) fora(v, vv) b.push_back(v);
  sort(b);
  unique(b);
  fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
void compress(ll a[], ll len) {
  vi b;
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define rlowerIndex(a, v) (upper_bound(all(a), v) - a.begin() - 1)
#define rupperIndex(a, v) (lower_bound(all(a), v) - a.begin() - 1)

template <class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) {
  auto it = lower_bound(a.begin(), a.end(), v);
  if (it == a.end())
    return banpei;
  else
    return *it;
}
template <class T, class U, class W> T lowerBound(ruiC<T> &a, U v, W banpei) {
  return lowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) {
  auto it = upper_bound(a.begin(), a.end(), v);
  if (it == a.end())
    return banpei;
  else
    return *it;
}
template <class T, class U, class W> T upperBound(ruiC<T> &a, U v, W banpei) {
  return upperBound(a.rui, v, banpei);
}
template <class T, class U, class W>
T rlowerBound(vector<T> &a, U v, W banpei) {
  auto it = upper_bound(a.begin(), a.end(), v);
  if (it == a.begin())
    return banpei;
  else {
    return *(--it);
  }
}
template <class T, class U, class W> T rlowerBound(ruiC<T> &a, U v, W banpei) {
  return rlowerBound(a.rui, v, banpei);
}
template <class T, class U, class W>
T rupperBound(vector<T> &a, U v, W banpei) {
  auto it = lower_bound(a.begin(), a.end(), v);
  if (it == a.begin())
    return banpei;
  else {
    return *(--it);
  }
}
template <class T, class U, class W> T rupperBound(ruiC<T> &a, U v, W banpei) {
  return rupperBound(a.rui, v, banpei);
}
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))

// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
  int n = sz(a);
  vi tail(n + 1, MAX(T));
  rep(i, n) {
    int id = lowerIndex(tail, a[i]); /**/
    tail[id] = a[i];
  }
  return lowerIndex(tail, MAX(T));
}
template <class T> int lis_eq(vector<T> &a) {
  int n = sz(a);
  vi tail(n + 1, MAX(T));
  rep(i, n) {
    int id = upperIndex(tail, a[i]); /**/
    tail[id] = a[i];
  }
  return lowerIndex(tail, MAX(T));
}

// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
  auto ret = m.lower_bound(k);
  while (ret != m.end() && (*ret).second == 0) {
    ret = m.erase(ret);
  }
  return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
  auto ret = m.upper_bound(k);
  while (ret != m.end() && (*ret).second == 0) {
    ret = m.erase(ret);
  }
  return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
  auto ret = upper_map(m, k);
  assert(ret != m.begin());
  ret--;
  while (1) {
    if ((*ret).second != 0)
      break;
    assert(ret != m.begin());
    auto next = ret;
    --next;
    m.erase(ret);
    ret = next;
  }
  return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
  auto ret = lower_map(m, k);
  assert(ret != m.begin());
  ret--;
  while (1) {
    if ((*ret).second != 0)
      break;
    assert(ret != m.begin());
    auto next = ret;
    --next;
    m.erase(ret);
    ret = next;
  }
  return ret;
}

template <class... T> void fin(T... s) {
  out(s...);
  exit(0);
}

// 便利 数学 math
// sub ⊂ top
bool subset(int sub, int top) { return (sub & top) == sub; }
//-180 ~ 180 degree
double atand(double h, double w) { return atan2(h, w) / PI * 180; }
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {
  if (m < 0)
    m *= -1;
  return (a % m + m) % m;
}
ll pow(ll a) { return a * a; };
ll fact(ll v) { return v <= 1 ? 1 : v * fact(v - 1); }
dou factd(int v) {
  static vd fact(2, 1);
  if (sz(fact) <= v) {
    rep(i, sz(fact), v + 1) { fact.push_back(fact.back() * i); }
  }
  return fact[v];
}

ll comi(ll n, ll r) {
  assert(n < 100);
  static vvi(pas, 100, 100);
  if (pas[0][0])
    return pas[n][r];
  pas[0][0] = 1;
  rep(i, 1, 100) {
    pas[i][0] = 1;
    rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
  }
  return pas[n][r];
}
double comd2(ll n, ll r) {
  static vvd(comb, 2020, 2020);
  if (comb[0][0] == 0) {
    comb[0][0] = 1;
    rep(i, 2000) {
      comb[i + 1][0] = 1;
      rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
    }
  }
  return comb[n][r];
}
double comd(int n, int r) {
  if (r < 0 || r > n)
    return 0;
  if (n < 2020)
    return comd2(n, r);
  static vd fact(2, 1);
  if (sz(fact) <= n) {
    rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
  }
  return fact[n] / fact[n - r] / fact[r];
}

ll gcd(ll a, ll b) {
  while (b)
    a %= b, swap(a, b);
  return abs(a);
}
ll gcd(vi b) {
  ll res = b[0];
  rep(i, 1, sz(b)) res = gcd(b[i], res);
  return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
  ll res = a[0];
  rep(i, 1, sz(a)) res = lcm(a[i], res);
  return res;
}
ll ceil(ll a, ll b) {
  if (b == 0) {
    debugline("ceil");
    deb(a, b);
    ole();
    return -1;
  } else if (a < 0) {
    return 0;
  } else {
    return (a + b - 1) / b;
  }
}

ll sig0(ll t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
// ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {
  if (s > t)
    swap(s, t);
  return sig0(t - s) + s * (t - s + 1);
}

#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) {
  assert(((v - st) % ad) == 0);
  return (v - st) / ad;
}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad; }

// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) {
  if (st >= v)
    return st;
  return (v - st + ad - 1) / ad * ad + st;
}
// 第何項か
ll lower_tosa_i(ll st, ll ad, ll v) {
  if (st >= v)
    return 0;
  return (v - st + ad - 1) / ad;
}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }

// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
  if (a < 0) {
    debugline("sqrt");
    deb(a);
    ole();
  }
  ll res = (ll)std::sqrt(a);
  while (res * res < a)
    ++res;
  return res;
}
double log(double e, double x) { return log(x) / log(e); }

/*@formatter:off*/

// 機能拡張
#define dtie(a, b)                                                             \
  int a, b;                                                                    \
  tie(a, b)
template <class T, class U> string to_string(T a, U b) {
  string res = "";
  res += a;
  res += b;
  return res;
}
template <class T, class U, class V> string to_string(T a, U b, V c) {
  string res = "";
  res += a;
  res += b;
  res += c;
  return res;
}
template <class T, class U, class V, class W>
string to_string(T a, U b, V c, W d) {
  string res = "";
  res += a;
  res += b;
  res += c;
  res += d;
  return res;
}
template <class T, class U, class V, class W, class X>
string to_string(T a, U b, V c, W d, X e) {
  string res = "";
  res += a;
  res += b;
  res += c;
  res += d;
  res += e;
  return res;
}

constexpr int bsetlen = k5 * 2;
// constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] < b[i])
      return true;
    if (a[i] > b[i])
      return false;
  }
  return false;
}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] > b[i])
      return true;
    if (a[i] < b[i])
      return false;
  }
  return false;
}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] < b[i])
      return true;
    if (a[i] > b[i])
      return false;
  }
  return true;
}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] > b[i])
      return true;
    if (a[i] < b[i])
      return false;
  }
  return true;
}
string operator~(string &a) {
  string res = a;
  for (auto &&c : res) {
    if (c == '0')
      c = '1';
    else if (c == '1')
      c = '0';
    else {
      cerr << "cant ~" << a << "must bit" << endl;
      exit(0);
    }
  }
  return res;
}
ostream &operator<<(ostream &os, bset &a) {
  bitset<10> b;
  vi list;
  rep(i, bsetlen) {
    if (a[i])
      list.push_back(i), b[i] = 1;
  }
  os << b << ", " << list;
  return os;
}
int hbiti(bset &a) {
  rer(i, bsetlen) {
    if (a[i])
      return i;
  }
  return -1;
}
#define hk(a, b, c) (a <= b && b < c)

// O(N/64)
bset nap(bset &a, int v) {
  bset r = a | a << v;
  return r;
}
bset nap(bset &a, bset &v) {
  bset r = a;
  rep(i, bsetlen) {
    if (v[i])
      r |= a << i;
  }
  return r;
}

template <class T> void seth(vector<vector<T>> &S, int w, vector<T> &v) {
  assert(sz(S) == sz(v));
  assert(w < sz(S[0]));
  rep(h, sz(S)) { S[h][w] = v[h]; }
}

template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
  a.fi += b.fi;
  a.se += b.se;
}
template <class T, class U> pair<T, U> operator+(pair<T, U> &a, pair<T, U> &b) {
  return pair<T, U>(a.fi + b.fi, a.se + b.se);
}

template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
  basic_string<CharT, Traits, Alloc> str(lhs);
  str.append(to_string(rv));
  return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
  lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
  basic_string<CharT, Traits, Alloc> str(lhs);
  str.append(to_string(rv));
  return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
  lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
  auto bek = s;
  s = "";
  for (; num; num >>= 1) {
    if (num & 1) {
      s += bek;
    }
    bek += bek;
  }
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
  a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
  fora(d, v) a.push(d);
  return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
  a.push(v);
  return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
  a.push(v);
  return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
  fora(d, v) a.insert(d);
  return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
  return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
  return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
  return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
  a.insert(v);
  return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
  a.push_back(v);
  return a;
}
template <class T, class U> vector<T> operator+(vector<T> &a, U v) {
  vector<T> ret = a;
  ret += v;
  return ret;
}
template <class T, class U> vector<T> operator+(U v, vector<T> &a) {
  vector<T> ret = a;
  ret.insert(ret.begin(), v);
  return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
  vector<T> ret;
  ret = a;
  fora(v, b) ret += v;
  return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
  rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
    a.push_back(b[i]);
  }
  return a;
}
template <class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) {
  fora(bv, b) { a[bv.first] += bv.second; }
  return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
  if (sz(a) != sz(b)) {
    debugline("vector<T> operator-=");
    deb(a);
    deb(b);
    exit(0);
  }
  rep(i, sz(a)) a[i] -= b[i];
  return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
  if (sz(a) != sz(b)) {
    debugline("vector<T> operator-");
    deb(a);
    deb(b);
    ole();
  }
  vector<T> res(sz(a));
  rep(i, sz(a)) res[i] = a[i] - b[i];
  return res;
}
template <class T, class U> void operator*=(vector<T> &a, U b) {
  vector<T> ta = a;
  rep(b - 1) { a += ta; }
}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
  v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
  v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
  v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
  v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
  v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
  for (auto &&va : list)
    v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
  for (auto &&va : list)
    v.insert(va);
}
vector<string> split(const string a, const char deli) {
  string b = a + deli;
  ll l = 0, r = 0, n = b.size();
  vector<string> res;
  rep(i, n) {
    if (b[i] == deli) {
      r = i;
      if (l < r)
        res.push_back(b.substr(l, r - l));
      l = i + 1;
    }
  }
  return res;
}
vector<string> split(const string a, const string deli) {
  vector<string> res;
  ll kn = sz(deli);
  std::string::size_type Pos(a.find(deli));
  ll l = 0;
  while (Pos != std::string::npos) {
    if (Pos - l)
      res.push_back(a.substr(l, Pos - l));
    l = Pos + kn;
    Pos = a.find(deli, Pos + kn);
  }
  if (sz(a) - l)
    res.push_back(a.substr(l, sz(a) - l));
  return res;
}
void yn(bool a) {
  if (a)
    cout << "yes" << endl;
  else
    cout << "no" << endl;
}
void Yn(bool a) {
  if (a)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
void YN(bool a) {
  if (a)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
}
void fyn(bool a) {
  if (a)
    cout << "yes" << endl;
  else
    cout << "no" << endl;
  exit(0);
}
void fYn(bool a) {
  if (a)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
  exit(0);
}
void fYN(bool a) {
  if (a)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
  exit(0);
}
void fAb(bool a) {
  if (a)
    cout << "Alice" << endl;
  else
    cout << "Bob";
}
void Possible(bool a) {
  if (a)
    cout << "Possible" << endl;
  else
    cout << "Impossible" << endl;
  exit(0);
}
void POSSIBLE(bool a) {
  if (a)
    cout << "POSSIBLE" << endl;
  else
    cout << "IMPOSSIBLE" << endl;
  exit(0);
}
template <typename T> class fixed_point : T {
public:
  explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
  template <typename... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return T::operator()(*this, std::forward<Args>(args)...);
  }
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
  return fixed_point<T>{std::forward<T>(t)};
}

// 未分類
// 0,2,1 1番目と2番目の次元を入れ替える
template <class T>
auto irekae(vector<vector<vector<T>>> &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c)                                            \
  resize(res, a, b, c);                                                        \
  rep(i, a) rep(j, b) rep(k, c)
  vector<vector<vector<T>>> res;
  if (x == 0 && y == 1 && z == 2) {
    res = A;
  } else if (x == 0 && y == 2 && z == 1) {
    irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) {
      res[i][j][k] = A[i][k][j];
    }
  } else if (x == 1 && y == 0 && z == 2) {
    irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) {
      res[i][j][k] = A[j][i][k];
    }
  } else if (x == 1 && y == 2 && z == 0) {
    irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) {
      res[i][j][k] = A[k][i][j];
    }
  } else if (x == 2 && y == 0 && z == 1) {
    irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) {
      res[i][j][k] = A[j][k][i];
    }
  } else if (x == 2 && y == 1 && z == 0) {
    irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) {
      res[i][j][k] = A[k][j][i];
    }
  }
  return res;
#undef irekae_resize_loop
}
template <class T> auto irekae(vector<vector<T>> &A, int i = 1, int j = 0) {
  vvt(res, sz(A[0]), sz(A));
  rep(i, sz(A)) {
    rep(j, sz(A[0])) { res[j][i] = A[i][j]; }
  }
  return res;
}
// tou分割する
template <typename T> vector<vector<T>> cut(vector<T> &a, int tou = 2) {
  int N = sz(a);
  vector<vector<T>> res(tou);
  int hab = N / tou;
  vi lens(tou, hab);
  rep(i, N % tou) { lens[tou - 1 - i]++; }
  int l = 0;
  rep(i, tou) {
    int len = lens[i];
    int r = l + len;
    res[i].resize(len);
    std::copy(a.begin() + l, a.begin() + r, res[i].begin());
    l = r;
  }
  return res;
}
// 長さn毎に分割する
template <typename T> vector<vector<T>> cutn(vector<T> &a, int len) {
  int N = sz(a);
  vector<vector<T>> res(ceil(N, len));
  vi lens(N / len, len);
  if (N % len)
    lens.push_back(N % len);
  int l = 0;
  rep(i, sz(lens)) {
    int len = lens[i];
    int r = l + len;
    res[i].resize(len);
    std::copy(a.begin() + l, a.begin() + r, res[i].begin());
    l = r;
  }
  return res;
}
vi inds_(vi &a) {
  int n = sz(a);
  vb was(n);
  vi res(n);
  rep(i, n) {
    assert(!was[a[i]]);
    res[a[i]] = i;
    was[a[i]] = true;
  }
  return res;
}

//@起動時
struct initon {
  initon() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    srand((unsigned)clock() + (unsigned)time(NULL));
  };
} initonv;
#define pre prev
#define nex next

// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
// 右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {
  while (++i < 4) {
    if (inside(h + h4[i], w + w4[i], H, W))
      return i;
  }
  return i;
}
#define mei(nh, nw, h, w)                                                      \
  for (int i = mei_inc(h, w, H, W, -1), nh = i < 4 ? h + h4[i] : 0,            \
           nw = i < 4 ? w + w4[i] : 0;                                         \
       i < 4; i = mei_inc(h, w, H, W, i), nh = h + h4[i], nw = w + w4[i])

// グラフ内で #undef getid
// #define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) (h * W + w)
#define getid_1(p) (p.first * W + p.second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
// #define set_shuffle() std::random_device seed_gen;std::mt19937
// engine(seed_gen()) #define shuffle(a) std::shuffle((a).begin(), (a).end(),
// engine); 1980 開始からtime ms経っていたらtrue
bool timeup(int time) {
  auto end_time = system_clock::now();
  auto part = duration_cast<milliseconds>(end_time - start_time);
  auto lim = milliseconds(time);
  return part >= lim;
}
void set_time() { past_time = system_clock::now(); }
// MS型(millisecqnds)で返る
// set_timeをしてからの時間
auto calc_time_milli() {
  auto now = system_clock::now();
  auto part = duration_cast<milliseconds>(now - past_time);
  return part;
}
auto calc_time_micro() {
  auto now = system_clock::now();
  auto part = duration_cast<microseconds>(now - past_time);
  return part;
}
auto calc_time_nano() {
  auto now = system_clock::now();
  auto part = duration_cast<nanoseconds>(now - past_time);
  return part;
}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS = std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {
  if (b < nanoseconds(1)) {
    return a / nanoseconds(1);
  }
  int v = a / b;
  return v;
}
// set_time();
// rep(i,lim)shori

// lim*=time_nanbai();
// rep(i,lim)shoriと使う
// 全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {
  auto dec = duration_cast<nanoseconds>(past_time - start_time);
  auto part = calc_time_nano();
  auto can_time = nanoseconds(milli * 1000 * 1000);
  can_time -= part;
  can_time -= dec;
  return div(can_time, part);
}
/*@formatter:on*/
// vectorで取れる要素数
// bool=> 1e9 * 8.32
// int => 1e8 * 2.6
// ll  => 1e8 * 1.3
// 3次元以上取るとメモリがヤバい
// static配列を使う

vvc(ba);
ll N, M, H, W;
vi A, B, C;
#undef getid
/*@formatter:off*/
#define forg(gi, ve)                                                           \
  for (ll gi = 0, forglim = ve.size(), f, t, c;                                \
       gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
#define fort(gi, ve)                                                           \
  for (ll gi = 0, f, t, c, wasp = (p != -1 && ve[gi].t == p) ? 1 : 0;          \
       (wasp = wasp                         ? 1                                \
               : (p != -1 && ve[gi].t == p) ? 1                                \
                                            : 0,                               \
       gi + wasp < ve.size()) &&                                               \
       (tie(f, t, c) =                                                         \
            wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c)        \
                 : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c),                   \
                  true);                                                       \
       ++gi)
#define fore(gi, ve)                                                           \
  for (ll gi = 0, forglim = ve.size(), f, t, c;                                \
       gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)

template <class T> struct edge_ {
  int f, t;
  T c;
  edge_(int f, int t, T c = 1) : f(f), t(t), c(c) {}
  bool operator<(const edge_ &b) const { return c < b.c; }
  bool operator>(const edge_ &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge_<T> &e) {
  os << e.f << " " << e.t << " " << e.c;
  return os;
}
template <typename T> class graph {
public:
  vector<vector<edge_<T>>> g;
  vector<edge_<T>> edges;
  int n;
  explicit graph(int n) : n(n) { g.resize(n); }
  void clear() { g.clear(), edges.clear(); }
  void resize(int n) {
    this->n = n;
    g.resize(n);
  }
  int size() { return n; }
  vector<edge_<T>> &operator[](int i) { return g[i]; }
  virtual void add(int f, int t, T c) = 0;
  virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
  using graph<T>::g;
  using graph<T>::n;
  using graph<T>::edges;
  explicit digraph(int n) : graph<T>(n) {}
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("digraph add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    edges.emplace_back(f, t, c); // edgesを使わないなら消せる
  }
  void ing(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t;
      cin >> f >> t;
      f -= minus;
      t -= minus;
      add(f, t);
    }
  }
  void ingc(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t, c;
      cin >> f >> t >> c;
      f -= minus;
      t -= minus;
      add(f, t, c);
    }
  }
  void set_edges() override {
    if (sz(edges))
      return;
    rep(i, n) fora(e, g[i]) edges.push_back(e);
  }
};
template <class T = int> class undigraph : public graph<T> {
public:
  using graph<T>::g;
  using graph<T>::n;
  using graph<T>::edges;
  explicit undigraph(int n) : graph<T>(n) {}
  // f < t
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("undigraph add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    g[t].emplace_back(t, f, c);
    edges.emplace_back(f, t, c); // edgesを使わないなら消せる
    edges.emplace_back(t, f, c);
  }
  void add(edge_<T> &e) {
    int f = e.f, t = e.t;
    T c = e.c;
    add(f, t, c);
  }
  void ing(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t;
      cin >> f >> t;
      f -= minus;
      t -= minus;
      add(f, t);
    }
  }
  void ingc(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t, c;
      cin >> f >> t >> c;
      f -= minus;
      t -= minus;
      add(f, t, c);
    }
  }
  void set_edges() override {
    if (sz(edges))
      return;
    rep(i, n) fora(e, g[i]) edges.push_back(e);
  }
};
#define dijkstra_path dis_path
template <class T>
vi dis_path(digraph<T> &g, vector<T> &dis, int s, int t, int init_value) {
  assert(dis[t] != init_value);
  auto rg = rev(g);
  int now = t;
  vi path;
  path.push_back(now);
  T cost = 0;
  while (now != s) {
    rep(gi, sz(rg[now])) {
      int m = rg[now][gi].t;
      if (dis[m] == init_value)
        continue;
      if (dis[m] + rg[now][gi].c + cost == dis[t]) {
        cost += rg[now][gi].c;
        now = m;
        break;
      }
    }
    path.push_back(now);
  }
  rev(path);
  return path;
}
template <class T>
vi dis_path(undigraph<T> &g, vector<T> &dis, int s, int t, int init_value) {
  assert(dis[t] != init_value);
  int now = t;
  vi path;
  path.push_back(now);
  T cost = 0;
  while (now != s) {
    rep(gi, sz(g[now])) {
      int m = g[now][gi].t;
      if (dis[m] == init_value)
        continue;
      if (dis[m] + g[now][gi].c + cost == dis[t]) {
        cost += g[now][gi].c;
        now = m;
        break;
      }
    }
    path.push_back(now);
  }
  rev(path);
  return path;
}
template <class T>
vi dis_path(digraph<T> &g, vector<vector<T>> &dis, int s, int t,
            int init_value) {
  return dis_path(g, dis[s], s, t, init_value);
}
template <class T>
vi dis_path(undigraph<T> &g, vector<vector<T>> &dis, int s, int t,
            int init_value) {
  return dis_path(g, dis[s], s, t, init_value);
}
// O(N^2)
template <class T> vector<T> dijkstra_mitu(graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra_mitu");
    deb(s, g.n);
    ole();
  }
  int n = g.n;
  int initValue = MAX(int);
  vector<T> dis(n, initValue);
  dis[s] = 0;
  vb used(n);
  while (true) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || dis[u] < dis[v]))
        v = u;
    }
    if (v == -1)
      break;
    if (dis[v] == initValue)
      break;
    used[v] = true;
    rep(u, sz(g[v])) {
      auto e = g[v][u];
      dis[e.t] = min(dis[e.t], dis[v] + e.c);
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis) {
    if (d == initValue) {
      d = init_value;
    }
  }
  return dis;
}
template <typename T> struct radixheap {
  vector<pair<u64, T>> v[65];
  u64 size, last;
  radixheap() : size(0), last(0) {}
  bool empty() const { return size == 0; }
  int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
  void push(u64 key, const T &value) {
    ++size;
    v[getbit(key ^ last)].emplace_back(key, value);
  }
  pair<u64, T> pop() {
    if (v[0].empty()) {
      int idx = 1;
      while (v[idx].empty())
        ++idx;
      last = min_element(begin(v[idx]), end(v[idx]))->first;
      for (auto &p : v[idx])
        v[getbit(p.first ^ last)].emplace_back(p);
      v[idx].clear();
    }
    --size;
    auto ret = v[0].back();
    v[0].pop_back();
    return ret;
  }
};
/*radix_heap こっちの方が早い*/
// O((N+M) log N)
vi dijkstra(graph<int> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  } /*O((N+M) log N) vs O(N^2)*/
  if ((g.n + sz(g.edges)) * log2(N) > g.n * g.n) {
    return dijkstra_mitu(g, s, init_value);
  }
  int initValue = MAX(int);
  vi dis(g.n, initValue);
  radixheap<int> q;
  dis[s] = 0;
  q.push(0, s);
  while (!q.empty()) {
    int nowc, i;
    tie(nowc, i) = q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      int c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        q.push(dis[to], to);
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return dis;
}
template <class T>
vector<T> dijkstra_normal(graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  }
  if ((g.n + sz(g.edges)) * 20 > g.n * g.n) {
    return dijkstra_mitu(g, s, init_value);
  }
  T initValue = MAX(T);
  vector<T> dis(g.n, initValue);
  priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
  dis[s] = 0;
  q.emplace(0, s);
  while (q.size()) {
    T nowc = q.top().fi;
    int i = q.top().se;
    q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      T c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        q.emplace(dis[to], to);
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return dis;
}
template <class T> vector<T> dijkstra_01(graph<T> &g, int s, int init_value) {
  int N = g.n;
  vi dis(N, linf);
  dis[s] = 0;
  deque<int> q;
  q.push_back(s);
  vb was(N);
  while (!q.empty()) {
    int f = q.front();
    q.pop_front();
    if (was[f])
      continue;
    was[f] = true;
    fora(e, g[f]) {
      if (dis[e.t] > dis[f] + e.c) {
        if (e.c) {
          dis[e.t] = dis[f] + 1;
          q.push_back(e.t);
        } else {
          dis[e.t] = dis[f];
          q.push_front(e.t);
        }
      }
    }
  }
  rep(i, N) if (dis[i] == linf) dis[i] = init_value;
  return dis;
}
// dijkstra_cou<mint> : 数える型で書く return vp(dis,cou)
template <class COU, class T = int>
auto dijkstra_cou(const graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  }
  err("count by type COU ");
  err("int or mint");
  T initValue = MAX(T);
  vector<T> dis(g.n, initValue);
  vector<COU> cou(g.n);
  cou[s] = 1;
  priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
  dis[s] = 0;
  q.emplace(0, s);
  while (q.size()) {
    T nowc = q.top().fi;
    int i = q.top().se;
    q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      T c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        cou[to] = cou[e.f];
        q.emplace(dis[to], to);
      } else if (dis[to] == c) {
        cou[to] += cou[e.f];
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return vtop(dis, cou);
}
// 密グラフの時、warshallに投げる
template <class T>
vector<vector<T>> dijkstra_all(const graph<T> &g, int init_value) {
  int n = g.n;
  assert(n < 1e4);
  if (n * n < (n + sz(g.edges)) * 14) { /*O(N^3) vs O(N (N+M)log N)*/
    return warshall(g, init_value);
  }
  vector<vector<T>> dis(n);
  rep(i, n) { dis[i] = dijkstra(g, i, init_value); }
  return dis;
}
// コストを無限に減らせる := -linf
// たどり着けない := linf
template <class T> vector<T> bell(graph<T> &g, int s) {
  if (g.n >= 1e4) {
    cout << "bell size too big" << endl;
    exit(0);
  }
  vector<T> res(g.n, linf);
  res[s] = 0;
  vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく */
  fix([&](auto ds, int p, int i) -> void {
    if (can[i])
      return;
    can[i] = true;
    forg(gi, g[i]) if (t != p) ds(i, t);
  })(-1, 0);
  vector<edge_<T>> es;
  fora(e, g.edges) {
    if (can[e.f])
      es += e;
  }
  rep(i, g.n) {
    bool upd = false;
    fora(e, es) {
      if (res[e.f] != linf && res[e.t] > res[e.f] + e.c) {
        upd = true;
        res[e.t] = res[e.f] + e.c;
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n * 2) {
    bool upd = 0;
    fora(e, g.edges) {
      if (res[e.f] != linf && res[e.t] != -linf && res[e.t] > res[e.f] + e.c) {
        upd = 1;
        res[e.t] = -linf;
      }
    }
    if (!upd)
      break;
  }
  return res;
}
// コストを無限に増やせる := linf
// たどり着けない := -linf
template <class T> vector<T> bell_far(graph<T> &g, int s) {
  if (g.n >= 1e4) {
    cout << "bell_far size too big" << endl;
    exit(0);
  }
  vector<T> res(g.n, linf);
  res[s] = 0;
  vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく*/
  fix([&](auto ds, int p, int i) -> void {
    if (can[i])
      return;
    can[i] = true;
    forg(gi, g[i]) if (t != p) ds(i, t);
  })(-1, 0);
  vector<edge_<T>> es;
  fora(e, g.edges) {
    if (can[e.f])
      es += e;
  }
  rep(i, g.n) {
    bool upd = false;
    fora(e, es) {
      if (res[e.f] != linf && res[e.t] > res[e.f] - e.c) { /*-c*/
        upd = true;
        res[e.t] = res[e.f] - e.c; /*-c*/
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n * 2) {
    bool upd = 0;
    fora(e, g.edges) {
      if (res[e.f] != linf && res[e.t] != -linf &&
          res[e.t] > res[e.f] - e.c) { /*-c*/
        upd = 1;
        res[e.t] = -linf;
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n) res[i] *= -1;
  return res;
}
template <class T> vector<vector<T>> warshall(graph<T> &g, int init_value) {
  int n = g.n;
  assert(n < 1e4);
  vector<vector<T>> dis(n, vector<T>(n, linf));
  rep(i, n) fora(e, g.g[i]) {
    if (dis[e.f][e.t] > e.c) {
      dis[e.f][e.t] = e.c;
    }
  }
  rep(i, n) dis[i][i] = 0;
  rep(k, n) rep(i, n) rep(j, n) {
    if (dis[i][j] > dis[i][k] + dis[k][j]) {
      dis[i][j] = dis[i][k] + dis[k][j];
    }
  }
  rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = init_value;
  return dis;
}
template <class T> class MinOp {
public:
  T operator()(T a, T b) { return min(a, b); }
};
template <typename OpFunc> struct SparseTable {
  OpFunc op;
  signed size;
  vector<signed> lg;
  vector<vector<pair<signed, signed>>> table;
  void init(vector<pair<signed, signed>> &array, OpFunc opfunc) {
    signed n = array.size();
    op = opfunc;
    lg.assign(n + 1, 0);
    for (signed i = 1; i <= n; i++) {
      lg[i] = 31 - __builtin_clz(i);
    }
    table.assign(lg[n] + 1, array);
    for (signed i = 1; i <= lg[n]; i++) {
      for (signed j = 0; j < n; j++) {
        if (j + (1 << (i - 1)) < n) {
          table[i][j] = op(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
        } else {
          table[i][j] = table[i - 1][j];
        }
      }
    }
  }
  pair<signed, signed> query(signed l, signed r) {
    assert(l < r);
    return op(table[lg[r - l]][l], table[lg[r - l]][r - (1 << lg[r - l])]);
  }
};
struct PMORMQ {
  vector<signed> a;
  SparseTable<MinOp<pair<signed, signed>>> sparse_table;
  vector<vector<vector<signed>>> lookup_table;
  vector<signed> block_type;
  signed block_size, n_block;
  void init(vector<signed> &array) {
    a = array;
    signed n = a.size();
    block_size = std::max(1, (31 - __builtin_clz(n)) / 2);
    while (n % block_size != 0) {
      a.push_back(a.back() + 1);
      n++;
    }
    n_block = n / block_size;
    vector<pair<signed, signed>> b(n_block, make_pair(INT_MAX, INT_MAX));
    for (signed i = 0; i < n; i++) {
      b[i / block_size] = min(b[i / block_size], make_pair(a[i], i));
    }
    sparse_table.init(b, MinOp<pair<signed, signed>>());
    block_type.assign(n_block, 0);
    for (signed i = 0; i < n_block; i++) {
      signed cur = 0;
      for (signed j = 0; j < block_size - 1; j++) {
        signed ind = i * block_size + j;
        if (a[ind] < a[ind + 1]) {
          cur |= 1 << j;
        }
      }
      block_type[i] = cur;
    }
    lookup_table.assign(
        1 << (block_size - 1),
        vector<vector<signed>>(block_size, vector<signed>(block_size + 1)));
    for (signed i = 0; i < (1 << (block_size - 1)); i++) {
      for (signed j = 0; j < block_size; j++) {
        signed res = 0;
        signed cur = 0;
        signed pos = j;
        for (signed k = j + 1; k <= block_size; k++) {
          lookup_table[i][j][k] = pos;
          if (i & (1 << (k - 1))) {
            cur++;
          } else {
            cur--;
          }
          if (res > cur) {
            pos = k;
            res = cur;
          }
        }
      }
    }
  }
  signed query(signed l, signed r) {
    assert(l < r);
    signed lb = l / block_size;
    signed rb = r / block_size;
    if (lb == rb) {
      return lb * block_size +
             lookup_table[block_type[lb]][l % block_size][r % block_size];
    }
    signed pl = lb * block_size +
                lookup_table[block_type[lb]][l % block_size][block_size];
    signed pr =
        rb * block_size + lookup_table[block_type[rb]][0][r % block_size];
    signed pos = pl;
    if (r % block_size > 0 && a[pl] > a[pr]) {
      pos = pr;
    }
    if (lb + 1 == rb) {
      return pos;
    }
    signed spv = sparse_table.query(lb + 1, rb).second;
    if (a[pos] > a[spv]) {
      return spv;
    }
    return pos;
  }
};

template <class T = int> class tree : public undigraph<T> {
  PMORMQ rmq;
  int cnt;
  vector<signed> id, in;
  bool never = true;
  bool never_hld = true;
  void dfs(int x, int p, int d, int dis = 0) {
    id[cnt] = x;
    par_[x] = p;
    rmq_dep.push_back(d);
    disv[x] = dis;
    in[x] = cnt++;
    forg(gi, g[x]) {
      if (t == p) {
        continue;
      }
      dfs(t, x, d + 1, dis + c);
      id[cnt] = x;
      rmq_dep.push_back(d);
      cnt++;
    }
  }
  void precalc() {
    never = false;
    cnt = 0;
    rmq_dep.clear();
    disv.assign(n, 0);
    in.assign(n, -1);
    id.assign(2 * n - 1, -1);
    par_.assign(n, -1);
    dfs(root, -1, 0);
    rmq.init(rmq_dep);
#ifdef _DEBUG
    if (n >= 100)
      return;
    cerr << "---tree---" << endl;
    rep(i, n) {
      if (!(i == root || sz(g[i]) > 1))
        continue;
      cerr << i << " -> ";
      vi ts;
      forg(gi, g[i]) {
        if (t != par_[i])
          ts.push_back(t);
      }
      rep(i, sz(ts) - 1) cerr << ts[i] << ", ";
      if (sz(ts))
        cerr << ts.back() << endl;
    }
    cerr << endl;
#endif
  }
  int pos;
  void hld_build() {
    never_hld = false;
    if (never)
      precalc();
    g.resize(n);
    vid.resize(n, -1);
    head.resize(n);
    heavy.resize(n, -1);
    depth.resize(n);
    inv.resize(n);
    subl.resize(n);
    subr.resize(n);
    dfs(root, -1);
    t = 0;
    dfs_hld(root);
#ifdef _DEBUG
    if (n >= 100)
      return;
    cerr << "---hld_index---" << endl;
    vi inds;
    rep(i, n) if (sz(g[i])) inds.push_back(i);
    rep(i, sz(inds)) {
      str s = tos(bel(inds[i]));
      cerr << std::right << std::setw(sz(s) + (i ? 1 : 0)) << inds[i];
    }
    cerr << endl;
    rep(i, sz(inds)) { cerr << bel(inds[i]) << " "; }
    cerr << endl << endl;
    cerr << "---hld_edge_index---" << endl;
    fora(e, edges) {
      if (e.f <= e.t)
        cerr << e.f << "-" << e.t << " " << bel(e) << endl;
    }
    cerr << endl << endl;
    cerr << "!!query!! edge or not edge carefull!!" << endl;
#endif
  }
  int dfs(int curr, int prev) {
    int sub = 1, max_sub = 0;
    heavy[curr] = -1;
    forg(i, g[curr]) {
      int next = t;
      if (next != prev) {
        depth[next] = depth[curr] + 1;
        int sub_next = dfs(next, curr);
        sub += sub_next;
        if (max_sub < sub_next)
          max_sub = sub_next, heavy[curr] = next;
      }
    }
    return sub;
  }
  int t = 0;
#ifndef __CLION_IDE__
  void dfs_hld(int v = 0) {
    vid[v] = subl[v] = t;
    t++;
    inv[subl[v]] = v;
    if (0 <= heavy[v]) {
      head[heavy[v]] = head[v];
      dfs_hld(heavy[v]);
    }
    forg(i, g[v]) if (depth[v] < depth[t]) if (t != heavy[v]) {
      head[t] = t;
      dfs_hld(t);
    }
    subr[v] = t;
  }
#endif //__CLION_IDE__
  vector<signed> rmq_dep;
  vi par_, depth, disv;
  vi childs;
  vi par_id_; // 親への辺のidを持つ
  vvi(ids_);  // 隣接で辺のidを持つ
public:
  using undigraph<T>::g;
  using undigraph<T>::n;
  using undigraph<T>::edges;
  int root;
  //(f,t)と(t,f)は同じidを持ち、[0,n-1]でadd順に割り振られる

  // 部分木の  [左端、右端)  index
  // 部分木の辺に加算する場合
  // add(subl[i],subr[i],x)
  // add(sub[i],sub[i+1],-x)
  vector<int> vid, head, heavy, inv, subl, subr;

  tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
  void change_root(int roo) {
    root = roo;
    precalc();
  }
  int lca(int a, int b) {
    if (never)
      precalc();
    int x = in[a];
    int y = in[b];
    if (x > y) {
      swap(x, y);
    }
    int pos = rmq.query(x, y + 1);
    return id[pos];
  }
  int dis(int a, int b) {
    if (never)
      precalc();
    int x = in[a];
    int y = in[b];
    if (x > y) {
      swap(x, y);
    }
    int pos = rmq.query(x, y + 1);
    int p = id[pos];
    return disv[a] + disv[b] - disv[p] * 2;
  }
  int dep(int a) {
    if (never)
      precalc();
    return disv[a];
  }
  int par(int a) {
    if (never)
      precalc();
    return par_[a];
  }
  bool isleaf(int i) {
    if (never)
      precalc();
    return (sz(g[i]) == 1 && i != root);
  }
  vi child(int r) {
    vi res;
    res.push_back(r);
    queue<int> q;
    q.push(r);
    while (!q.empty()) {
      int i = q.front();
      res.push_back(i);
      q.pop();
      forg(gi, g[i]) {
        if (t != par(i))
          q.push(t);
      }
    }
    return res;
  }
  vb child_ex(int r) {
    vb res(n);
    res[r] = true;
    queue<int> q;
    q.push(r);
    while (!q.empty()) {
      int i = q.front();
      res[i] = true;
      q.pop();
      forg(gi, g[i]) {
        if (t != par(i))
          q.push(t);
      }
    }
    return res;
  }
  int dfs_count_subtree(int p, int i) {
    childs[i] = 1;
    fort(gi, g[i]) { childs[i] += dfs_count_subtree(i, t); }
    return childs[i];
  }
#define count_child count_subtree
  int count_subtree(int f) {
    if (sz(childs) == 0) {
      if (never)
        precalc();
      childs.resize(n);
      dfs_count_subtree(-1, root);
    }
    return childs[f];
  }
  // fからtの辺を切った時のtの大きさ
  int count_subtree(int f, int t) {
    if (par(f) == t) {
      return n - count_subtree(f);
    } else {
      return count_subtree(t);
    }
  }
  vi path(int a, int b) {
    vi res;
    for_each_l(a, b, [&](int i) { res.push_back(i); });
    return res;
  }
  int par_id(int i) {
    if (sz(par_id_) == 0) {
      pathe(0, 0);
    }
    return par_id_[i];
  }
  int ids(int f, int i) {
    if (sz(ids_) == 0) {
      pathe(0, 0);
    }
    return ids_[f][i];
  }
  edge_<T> edge(int id) { return edges[id << 1]; }
  // pathに含まれる辺のid達を返す
  vi pathe(int a, int b) {
#ifdef _DEBUG
    static bool was = 0;
    if (!was)
      message += "can't edges[id]. must edge(id)\n";
    was = 1;
#endif
    if (sz(par_id_) == 0) {
      ids_.resize(n);
      par_id_.resize(n);
      rep(i, 0, sz(edges), 2) {
        ids_[edges[i].f].emplace_back(i >> 1);
        ids_[edges[i].t].emplace_back(i >> 1);
      }
      if (never)
        precalc(); /*par_を呼ぶため*/
      rep(i, n) {
        int pa = par_[i];

        forg(gi, g[i]) {
          if (t == pa) {
            par_id_[i] = ids_[i][gi];
          }
        }
      }
    }
    int u = lca(a, b);
    vi res;
    if (a != u) {
      do {
        res.emplace_back(par_id_[a]);
        a = par_[a];
      } while (a != u);
    }
    vi rev;
    if (b != u) {
      do {
        rev.emplace_back(par_id_[b]);
        b = par_[b];
      } while (b != u);
    }
    rer(i, sz(rev) - 1) { res.emplace_back(rev[i]); }
    return res;
  }
  /*O(N) hldを使わず木を普通にたどる liteの意*/
  void for_each_l(int u, int v, function<void(int)> fnode) {
    int r = lca(u, v);
    while (u != r) {
      fnode(u);
      u = par_[u];
    }
    fnode(r);
    vi a;
    while (v != r) {
      a.push_back(v);
      v = par_[v];
    }
    while (sz(a)) {
      fnode(a.back());
      a.pop_back();
    }
  }
  void for_each_edge_l(int u, int v, function<void(edge_<int> &)> fedge) {
    int r = lca(u, v);
    while (u != r) {
      forg(gi, g[u]) {
        if (t == par_[u]) {
          fedge(g[u][gi]);
          u = par_[u];
          break;
        }
      }
    }
    vector<edge_<int>> qs;
    while (v != r) {
      forg(gi, g[v]) {
        if (t == par_[v]) {
          qs.push_back(g[v][gi]);
          v = par_[v];
          break;
        }
      }
    }
    while (sz(qs)) {
      fedge(qs.back());
      qs.pop_back();
    }
  }
  // Fは半開 (u,v)は木の頂点
  // 中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう
  void for_each_ /*[l,r)*/ (int u, int v, const function<void(int, int)> &f) {
    if (never_hld)
      hld_build();
    while (1) {
      if (vid[u] > vid[v])
        swap(u, v);
      int l = max(vid[head[v]], vid[u]);
      int r = vid[v] + 1;
      f(l, r);
      if (head[u] != head[v])
        v = par_[head[v]];
      else
        break;
    }
  }
  void for_each_edge /*[l,r) O(log(N)) 辺を頂点として扱っている
                        上と同じ感じで使える*/
      (int u, int v, const function<void(int, int)> &f) {
    if (never_hld)
      hld_build();
    while (1) {
      if (vid[u] > vid[v])
        swap(u, v);
      if (head[u] != head[v]) {
        int l = vid[head[v]];
        int r = vid[v] + 1;
        f(l, r);
        v = par_[head[v]];
      } else {
        if (u != v) {
          int l = vid[u] + 1;
          int r = vid[v] + 1;
          f(l, r);
        }
        break;
      }
    }
  }
  int bel(int v) { /*hld内での頂点番号を返す*/
    if (never_hld)
      hld_build();
    return vid[v];
  }
  // 下の頂点に辺のクエリを持たせている
  int bel(
      int f,
      int t) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
    if (never_hld)
      hld_build();
    return depth[f] > depth[t] ? vid[f] : vid[t];
  }
  int bel(
      edge_<T> &
          e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
    if (never_hld)
      hld_build();
    return depth[e.f] > depth[e.t] ? vid[e.f] : vid[e.t];
  }
  template <class... U> int operator()(U... args) { return bel(args...); }
  // path l -> r += v
  template <class S> void seg_add(S &seg, int lhei, int rhei, int v) {
    for_each_(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });
  }
  template <class S> void seg_update(S &seg, int lhei, int rhei, int v) {
    for_each_(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });
  }
  template <class S> T seg_get(S &seg, int lhei, int rhei) {
    T res = seg.e;
    for_each_(lhei, rhei,
              [&](int l, int r) { res = seg.f(res, seg.get(l, r)); });
    return res;
  }
  template <class S> void seg_add_edge(S &seg, int lhei, int rhei, int v) {
    for_each_edge(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });
  }
  template <class S> void seg_update_edge(S &seg, int lhei, int rhei, int v) {
    for_each_edge(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });
  }
  template <class S> T seg_get_edge(S &seg, int lhei, int rhei) {
    T res = seg.e;
    for_each_edge(lhei, rhei,
                  [&](int l, int r) { res = seg.f(res, seg.get(l, r)); });
    return res;
  }
  // 単体   edgeは上で処理できる
  template <class S> void seg_add(S &seg, int i, int v) { seg.add(bel(i), v); }
  template <class S> void seg_update(S &seg, int i, int v) {
    seg.update(bel(i), v);
  }
  template <class S> T seg_get(S &seg, int i) { return seg[i]; }
  template <class S> void seg_del(S &seg, int i) { seg.del(bel(i)); }

  // 部分木iに対するクエリ
  template <class S> void seg_add_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    seg.add(subl[i], subr[i], v);
  }
  template <class S> void seg_update_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    seg.update(subl[i], subr[i], v);
  }
  template <class S> T seg_get_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    return seg.get(subl[i], subr[i], v);
  }
  template <class S> void seg_add_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    seg.add(subl[i] + 1, subr[i], v);
  }
  template <class S> void seg_update_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    seg.update(subl[i] + 1, subr[i], v);
  }
  template <class S> T seg_get_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    return seg.get(subl[i] + 1, subr[i], v);
  }
};
// 辺が多いのでedgesを持たない
// cost oo, ox, xo, xx 渡す
template <class T = int> class grid_k6 : public undigraph<T> {
  vi costs;

public:
  using undigraph<T>::g;
  using undigraph<T>::n;
  using undigraph<T>::edges;
  int H, W;
  vector<vector<char>> ba;
  char wall;

  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("grid_k6 add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    g[t].emplace_back(t, f, c);
    // undigraphと違い、edgesを持たない
  }
  int getid(int h, int w) {
    assert(ins(h, w, H, W));
    return W * h + w;
  }
  int getid(P p) { return getid(p.first, p.second); }
  P get2(int id) { return mp(id / W, id % W); }
  P operator()(int id) { return get2(id); }
  int operator()(int h, int w) { return getid(h, w); }
  int operator()(P p) { return getid(p); }
  // 辺は無い
  grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {}
  grid_k6(vector<vector<char>> ba, char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
    rep(h, H) {
      rep(w, W) {
        if (ba[h][w] == wall)
          con;
        int f = getid(h, w);
        if (w + 1 < W && ba[h][w + 1] != wall) {
          add(f, getid(h, w + 1));
        }
        if (h + 1 < H && ba[h + 1][w] != wall) {
          add(f, getid(h + 1, w));
        }
      }
    }
  }
  /*o -> o, o -> x, x-> x*/
  grid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx,
          char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])),
        costs({oo, ox, xo, xx}), ba(ba), wall(wall) {
    rep(h, H) {
      rep(w, W) {
        add(h, w, h + 1, w);
        add(h, w, h - 1, w);
        add(h, w, h, w + 1);
        add(h, w, h, w - 1);
      }
    }
  }
  void add(int fh, int fw, int th, int tw) {
    if (ins(fh, fw, H, W) && ins(th, tw, H, W)) {
      int cm = 0;
      if (ba[fh][fw] == wall) {
        cm += 2;
      }
      if (ba[th][tw] == wall) {
        cm++;
      }
      int f = getid(fh, fw);
      int t = getid(th, tw);
      g[f].emplace_back(f, t, costs[cm]);
    }
  }
  void set_edges() {
    rep(i, n) fora(e, g[i]) if (e.f < e.t) edges.push_back(e);
  }
};

// 辺によりメモリを大量消費ためedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  int H, W;
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("digrid_k6 add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    /*digraphと違いedgesを持たない*/
  }
  int getid(int h, int w) {
    if (!ins(h, w, H, W))
      return -1;
    return W * h + w;
  }
  P get2(int id) { return mp(id / W, id % W); }
  P operator()(int id) { return get2(id); }
  int operator()(int h, int w) { return getid(h, w); }
  digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {}
  digrid_k6(vector<vector<char>> ba, char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
    rep(h, H) {
      rep(w, W) {
        if (ba[h][w] == wall)
          con;
        int f = getid(h, w);
        if (w + 1 < W && ba[h][w + 1] != wall) {
          add(f, getid(h, w + 1));
        }
        if (h + 1 < H && ba[h + 1][w] != wall) {
          add(f, getid(h + 1, w));
        }
      }
    }
  }
  void add(int fh, int fw, int th, int tw) {
    add(getid(fh, fw), getid(th, tw));
  }
  void set_edges() { rep(i, n) fora(e, g[i]) edges.push_back(e); }
};
// edgesを持たない
// dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template <class T = int> class segdi : public digraph<T> {
  int getid(int k) {
    if (k >= len * 2 - 1) {
      return k;
    } else if (k < len - 1) {
      return k + len;
    } else {
      return k - len + 1;
    }
  }
  void add(int f, int t, T c = 1) {
    f = getid(f);
    t = getid(t);
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("segdi add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/
  }
  int mid;
  int len;

public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  // 頂点が足りなくなったらresize
  segdi(int n_) : digraph<T>(1) {
    int nn = 1;
    while (nn < n_)
      nn *= 2;
    n_ = nn;
    len = n_;
    this->resize(n_ + (n_ - 1) * 2 + n_);
    mid = n_ + (n_ - 1) * 2;
    int ad = len * 2 - 1;
    rep(i, len - 1) {
      add(i, i * 2 + 1, 0);
      add(i, i * 2 + 2, 0);
      if (i * 2 + 1 >= len - 1) {
        add(i * 2 + 1, i + ad, 0);
        add(i * 2 + 2, i + ad, 0);
      } else {
        add(i * 2 + 1 + ad, i + ad, 0);
        add(i * 2 + 2 + ad, i + ad, 0);
      }
    }
  }
  void dfs(vi &list, int nl, int nr, int k, int l, int r) {
    if (r <= nl || nr <= l)
      return;
    if (l <= nl && nr <= r) {
      list += k;
    } else {
      dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r);
      dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r);
    }
  }
  void rekkyo(vi &list, int l, int r) {
    l += len - 1;
    r += len - 1;
    while (l < r) {
      if (!(l & 1)) {
        list.push_back(l);
      }
      if (!(r & 1)) {
        list.push_back(r - 1);
      }
      l >>= 1;
      r = (r - 1) >> 1;
    }
  }
  // 半開
  void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/
    int ad = 2 * len - 1;
    if (mid >= n) {
      this->resize(n + 100);
    }
    {
      int l = fl, r = fr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          if (l - len + 1 < 0)
            add(l + ad, mid, cost);
          else
            add(l, mid, cost);
        }
        if (!(r & 1)) {
          if (r - 1 - len + 1 < 0)
            add(r - 1 + ad, mid, cost);
          else
            add(r - 1, mid, cost);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    {
      int l = tl, r = tr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          add(mid, l, 0);
        }
        if (!(r & 1)) {
          add(mid, r - 1, 0);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    mid++;
  }
};
// edgesを持たない
// dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template <class T = int> class segun : public undigraph<T> {
  int getid(int k) {
    if (k >= len * 2 - 1) {
      return k;
    } else if (k < len - 1) {
      return k + len;
    } else {
      return k - len + 1;
    }
  }
  void add(int f, int t, T c = 1) {
    f = getid(f);
    t = getid(t);
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("segun add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/
    g[t].emplace_back(t, f, c); /*digraphと違いedgesを持たない*/
  }
  int mid;
  int len;

public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  // 頂点が足りなくなったらresize
  segun(int n_) : digraph<T>(1) {
    int nn = 1;
    while (nn < n_)
      nn *= 2;
    n_ = nn;
    len = n_;
    this->resize(n_ + (n_ - 1) * 2 + n_);
    mid = n_ + (n_ - 1) * 2;
    int ad = len * 2 - 1;
    rep(i, len - 1) {
      add(i, i * 2 + 1, 0);
      add(i, i * 2 + 2, 0);
      if (i * 2 + 1 >= len - 1) {
        add(i * 2 + 1, i + ad, 0);
        add(i * 2 + 2, i + ad, 0);
      } else {
        add(i * 2 + 1 + ad, i + ad, 0);
        add(i * 2 + 2 + ad, i + ad, 0);
      }
    }
  }
  void dfs(vi &list, int nl, int nr, int k, int l, int r) {
    if (r <= nl || nr <= l)
      return;
    if (l <= nl && nr <= r) {
      list += k;
    } else {
      dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r);
      dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r);
    }
  }
  void rekkyo(vi &list, int l, int r) {
    l += len - 1;
    r += len - 1;
    while (l < r) {
      if (!(l & 1)) {
        list.push_back(l);
      }
      if (!(r & 1)) {
        list.push_back(r - 1);
      }
      l >>= 1;
      r = (r - 1) >> 1;
    }
  }
  // 半開
  void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/
    int ad = 2 * len - 1;
    if (mid >= n) {
      this->resize(n + 100);
    }
    {
      int l = fl, r = fr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          if (l - len + 1 < 0)
            add(l + ad, mid, cost);
          else
            add(l, mid, cost);
        }
        if (!(r & 1)) {
          if (r - 1 - len + 1 < 0)
            add(r - 1 + ad, mid, cost);
          else
            add(r - 1, mid, cost);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    {
      int l = tl, r = tr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          add(mid, l, 0);
        }
        if (!(r & 1)) {
          add(mid, r - 1, 0);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    mid++;
  }
};
#define getid_2(h, w) (h * W + w)
#define getid_1(p) (p.first * W + p.second)
#define o_getid(a, b, name, ...) name
#define getid(...) o_getid(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)

#define unionfind unionfind_graph
struct unionfind {
  vector<ll> par;
  vector<ll> siz;
  vector<ll> es;
  ll n, trees; // 連結グループの数(親の種類)
  unionfind(ll n) : n(n), trees(n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
  }
  template <class T> unionfind(graph<T> &g) : n(g.n), trees(g.n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
    add(g);
  }
  ll root(ll x) {
    if (par[x] == x) {
      return x;
    } else {
      return par[x] = root(par[x]);
    }
  }
  ll operator()(ll x) { return root(x); }
  bool unite(ll x, ll y) {
    x = root(x);
    y = root(y);
    es[x]++;
    if (x == y)
      return false;
    if (siz[x] > siz[y])
      swap(x, y);
    trees--;
    par[x] = y;
    siz[y] += siz[x];
    es[y] += es[x];
    return true;
  }
  template <class T> void add(graph<T> &g) {
    fora(e, g.edges) { unite(e.f, e.t); }
  }
  template <class T> void unite(graph<T> &g) { add(g); }
  bool same(ll x, ll y) { return root(x) == root(y); }
  ll size(ll x) { return siz[root(x)]; }
  ll esize(ll x) { return es[root(x)]; }
  vi sizes() {
    vi cou(n);
    vi ret;
    ret.reserve(n);
    rep(i, n) { cou[root(i)]++; }
    rep(i, n) {
      if (cou[i])
        ret.push_back(cou[i]);
    }
    return ret;
  }
  // つながりを無向グラフと見なし、xが閉路に含まれるか判定
  bool close(ll x) { return esize(x) >= size(x); }
  vector<vi> sets() {
    vi ind(n, -1);
    ll i = 0;
    vvi(res, trees);
    rep(j, n) {
      ll r = root(j);
      if (ind[r] == -1)
        ind[r] = i++;
      res[ind[r]].push_back(j);
    }
    rep(i, trees) {
      ll r = root(res[i][0]);
      if (res[i][0] == r)
        continue;
      rep(j, 1, sz(res[i])) {
        if (res[i][j] == r) {
          swap(res[i][0], res[i][j]);
          break;
        }
      }
    }
    return res;
  }
}; //@formatter:off

//@出力
template <class T> ostream &operator<<(ostream &os, digraph<T> &g) {
  os << endl << g.n << " " << sz(g.edges) << endl;
  fore(gi, g.edges) { os << f << " " << t << " " << c << endl; }
  return os;
}
template <class T> ostream &operator<<(ostream &os, undigraph<T> &g) {
  os << endl << g.n << " " << sz(g.edges) / 2 << endl;
  fore(gi, g.edges) {
    if (f < t)
      os << f << " " << t << " " << c << endl;
  }
  return os;
}

//@判定
template <class T> bool nibu(graph<T> &g) {
  int size = 0;
  rep(i, g.n) size += sz(g.g[i]);
  if (size == 0)
    return true;
  unionfind uf(g.n * 2);
  rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
      uf.unite(e.f + g.n, e.t);
  rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
  return true;
}
// 頂点ではなく辺の数に依存した計算量 O(E)
template <class T> bool nibu_sub(graph<T> &g) {
  umapi col;         /*0なら無色 */
  queue<int> q;      /*色は01か11 */
  fora(e, g.edegs) { /*fとtの色を持つか否かは同じ*/
    if (col[e.f] == 0)
      q.push(e.f);
    while (!q.empty()) {
      int f = q.front();
      q.pop();
      int fc = col[f];
      forg(gi, g[f]) {
        int &tc = col[t]; /*fcには色がある*/
        if (fc == tc)
          return false; /*違う色*/
        if (tc)
          continue; /*無色*/
        tc = fc ^ 2;
        q.push(tc);
      }
    }
  }
  return true;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
  vp cg;
  if (!nibu(g)) {
    debugline("nibu");
    ole();
  }
  int n = g.size();
  vb was(n);
  queue<P> q;
  rep(i, n) {
    if (was[i])
      continue;
    q.push(mp(i, 1));
    was[i] = 1;
    int red = 0;
    int coun = 0;
    while (q.size()) {
      int now = q.front().fi;
      int col = q.front().se;
      red += col;
      coun++;
      q.pop();
      forg(gi, g[now]) {
        if (was[t])
          continue;
        q.push(mp(t, col ^ 1));
        was[t] = 1;
      }
    }
    cg.push_back(mp(red, coun - red));
  }
  return cg;
}
// 連結グラフが与えられる 閉路があるか
template <class T> bool close(undigraph<T> &g) {
  int n = 0;
  int e = 0;
  rep(i, g.n) {
    if (sz(g[i]))
      n++;
    forg(gi, g[i]) { e++; }
  }
  return (e >> 1) >= n;
}
template <class T> bool close(undigraph<T> &g, int v) {
  unionfind uf(g.n);
  rep(i, g.n) {
    forg(gi, g[i]) {
      if (f < t)
        break;
      if (f == t && f == v)
        return true;
      if (uf.same(f, v) && uf.same(t, v))
        return true;
      uf.unite(f, t);
    }
  }
  return false;
}
template <class T> bool close(digraph<T> &g) {
  vi res;
  return topo(res, g);
}

//@変形
// 条件(f!=0等 f,t,cが使える)を満たすsubgraphをg2に代入
#define sub_di(g, g2, zhouken)                                                 \
  {                                                                            \
    g2.resize(g.n);                                                            \
    fore(gi, g.edges) {                                                        \
      if (zhouken) {                                                           \
        g2.add(f, t, c);                                                       \
      }                                                                        \
    }                                                                          \
  }
#define sub_un(g, g2, zhouken)                                                 \
  {                                                                            \
    g2.resize(g.n);                                                            \
    fore(gi, g.edges) {                                                        \
      bool ok = zhouken; /*片方がアウトなら駄目という扱い*/     \
      swap(f, t);                                                              \
      ok &= zhouken;                                                           \
      if (ok && f < t) {                                                       \
        g2.add(f, t, c);                                                       \
      }                                                                        \
    }                                                                          \
  }
#define sub_tree sub_un
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
  int n = g.g.size();
  vi nyu(n);
  rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
  queue<int> st;
  rep(i, n) if (nyu[i] == 0) st.push(i);
  while (st.size()) {
    int v = st.front();
    st.pop();
    res.push_back(v);
    fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
  }
  return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
  int n = g.g.size();
  vi nyu(n);
  rep(i, n) for (auto &&e : g[i]) nyu[e.t]++; /*小さい順*/
  priority_queue<int, vector<int>, greater<int>> q;
  rep(i, n) if (nyu[i] == 0) q.push(i);
  while (q.size()) {
    int i = q.top();
    q.pop();
    res.push_back(i);
    fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
  }
  return res.size() == n;
}
template <class T> digraph<T> rev(digraph<T> &g) {
  digraph<T> r(g.n);
  rep(i, g.n) {
    forg(gi, g[i]) { r.add(t, f, c); }
  }
  return r;
}
// lc,rcは子を持つ中で一番左、右
//(g,ind,l,r)
template <class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r) {
  if (sz(ind)) {
    cerr << "ind must be empty" << endl;
    exit(0);
  }
  int N = sz(g);
  ind.resize(N);
  l.resize(N, inf);
  r.resize(N, -1);
  tree<T> h(N);
  queue<P> q;
  q.emplace(-1, 0);
  int c = 0;
  while (sz(q)) {
    int p = q.front().first;
    int i = q.front().second;
    q.pop();
    ind[i] = c;
    if (~p)
      chmi(l[ind[p]], c);
    if (~p)
      chma(r[ind[p]], c);
    c++;
    forg(gi, g[i]) {
      if (t != p)
        q.emplace(i, t);
    }
  }
  fora(e, g.edges) {
    if (e.f < e.t) {
      h.add(ind[e.f], ind[e.t], e.c);
    }
  }
  rep(i, N) {
    if (l[i] == inf)
      l[i] = -1;
  }
  return h;
}
// lc,rcは子を持つ中で一番左、右
//  たとえばl[lc[x]は2段下の最左
//(g,ind,l,r,lc,rc)
template <class T>
tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r, vi &lc, vi &rc) {
  if (sz(ind)) {
    cerr << "ind must be empty" << endl;
    exit(0);
  }
  int N = sz(g);
  ind.resize(N);
  l.resize(N, inf);
  lc.resize(N, inf);
  r.resize(N, -1);
  rc.resize(N, -1);
  tree<T> h(N);
  queue<P> q;
  q.emplace(-1, 0);
  int c = 0;
  while (sz(q)) {
    int p = q.front().first;
    int i = q.front().second;
    q.pop();
    ind[i] = c;
    if (~p) {
      chmi(l[ind[p]], c);
      chma(r[ind[p]], c);
      if (sz(g[i]) > 1) {
        chmi(lc[ind[p]], c);
        chma(rc[ind[p]], c);
      }
    }
    c++;
    forg(gi, g[i]) {
      if (t != p)
        q.emplace(i, t);
    }
  }
  fora(e, g.edges) {
    if (e.f < e.t) {
      h.add(ind[e.f], ind[e.t], e.c);
    }
  }
  rep(i, N) {
    if (l[i] == inf)
      l[i] = -1;
    if (lc[i] == inf)
      lc[i] = -1;
  }
  return h;
}

//@集計
template <class T> vi indegree(graph<T> &g) {
  vi ret(g.size());
  rep(i, g.size()) {
    forg(gi, g[i]) { ret[t]++; }
  }
  return ret;
}
template <class T> vi outdegree(graph<T> &g) {
  vi ret(g.size());
  rep(i, g.size()) { ret[i] = g[i].size(); }
  return ret;
}
#define kansetu articulation
// private
/*private*/ P farthest____(tree<> &E, int cur, int pre, int d, vi &D) {
  D[cur] = d;
  P r = {d, cur};
  forg(gi, E[cur]) if (t != pre) {
    P v = farthest____(E, t, cur, d + 1, D);
    r = max(r, v);
  }
  return r;
}
// dagでなければ-1を返す
int diameter(digraph<> &g) {
  vi per;
  if (!topo(per, g))
    return -1;
  int n = g.n;
  vi dp(n, 1);
  fora(v, per) {
    forg(gi, g[v]) { chma(dp[t], dp[f] + 1); }
  }
  return max(dp);
}
// iから最も離れた距離
vi diameters(tree<> &E) { /* diameter,center*/
  vi D[3];
  D[0].resize(E.size());
  D[1].resize(E.size());
  auto v1 = farthest____(E, 0, 0, 0, D[0]);
  auto v2 = farthest____(E, v1.second, v1.second, 0, D[0]);
  farthest____(E, v2.second, v2.second, 0, D[1]);
  int i;
  rep(i, D[0].size()) D[2].push_back(max(D[0][i], D[1][i]));
  return D[2];
}
// iに対応するjと距離
vp diameters_p(tree<> &E) { /* diameter,center*/
  vector<int> D[3];
  D[0].resize(E.size());
  D[1].resize(E.size());
  auto v1 = farthest____(E, 0, 0, 0, D[0]);
  auto v2 = farthest____(E, v1.second, v1.second, 0, D[0]);
  farthest____(E, v2.second, v2.second, 0, D[1]);
  int i;
  vp res(E.size());
  rep(i, D[0].size()) {
    if (D[0][i] > D[1][i])
      res[i] = mp(v1.second, D[0][i]);
    else
      res[i] = mp(v2.second, D[1][i]);
  }
  return res;
}
int diameter(tree<> &E) {
  vi d = diameters(E);
  return max(d);
}
// 最も離れた二点を返す
P diameter_p(tree<> &E) {
  auto d = diameters_p(E);
  int dis = -1;
  int l = -1, r = -1;
  rep(i, sz(d)) {
    if (chma(dis, d[i].se)) {
      l = i;
      r = d[i].fi;
    }
  }
  return mp(l, r);
}
//@列挙 取得
// 閉路がある時linfを返す
template <class T> int longest_path(digraph<T> &g) {
  vi top;
  if (!topo(top, g)) {
    return linf;
  }
  int n = sz(top);
  vi dp(n, 0);
  for (auto &&i : top) {
    forg(gi, g[i]) { chma(dp[t], dp[i] + 1); }
  }
  return max(dp);
}
template <class T> vi longest_path_v(digraph<T> &g) {
  vi top;
  if (!topo(top, g)) {
    return vi();
  }
  int n = sz(top);
  vi dp(n, 0);
  vi pre(n, -1);
  for (auto &&i : top) {
    forg(gi, g[i]) {
      if (chma(dp[t], dp[i] + 1)) {
        pre[t] = i;
      }
    }
  }
  int s = std::max_element(dp.begin(), dp.end()) - dp.begin();
  vi path;
  while (s != -1) {
    path.push_back(s);
    s = pre[s];
  }
  std::reverse(path.begin(), path.end());
  return path;
}
// 橋を列挙する (取り除くと連結でなくなる辺)
template <class T> vp bridge(graph<T> &G) {
  static bool was;
  vp brid;
  vi articulation;
  vi ord(G.n), low(G.n);
  vb vis(G.n);
  function<void(int, int, int)> dfs = [&](int v, int p, int k) {
    vis[v] = true;
    ord[v] = k++;
    low[v] = ord[v];
    bool isArticulation = false;
    int ct = 0;
    for (int i = 0; i < G[v].size(); i++) {
      if (!vis[G[v][i].t]) {
        ct++;
        dfs(G[v][i].t, v, k);
        low[v] = min(low[v], low[G[v][i].t]);
        if (~p && ord[v] <= low[G[v][i].t])
          isArticulation = true;
        if (ord[v] < low[G[v][i].t])
          brid.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
      } else if (G[v][i].t != p) {
        low[v] = min(low[v], ord[G[v][i].t]);
      }
    }
    if (p == -1 && ct > 1)
      isArticulation = true;
    if (isArticulation)
      articulation.push_back(v);
  };
  int k = 0;
  rep(i, G.n) {
    if (!vis[i])
      dfs(i, -1, k);
  }
  sort(brid.begin(), brid.end());
  return brid;
}
// 間接点を列挙する (取り除くと連結でなくなる点)
template <class T> vi articulation(undigraph<T> &G) {
  static bool was;
  vp bridge;
  vi arti;
  vi ord(G.n), low(G.n);
  vb vis(G.n);
  function<void(int, int, int)> dfs = [&](int v, int p, int k) {
    vis[v] = true;
    ord[v] = k++;
    low[v] = ord[v];
    bool isArticulation = false;
    int ct = 0;
    for (int i = 0; i < G[v].size(); i++) {
      if (!vis[G[v][i].t]) {
        ct++;
        dfs(G[v][i].t, v, k);
        low[v] = min(low[v], low[G[v][i].t]);
        if (~p && ord[v] <= low[G[v][i].t])
          isArticulation = true;
        if (ord[v] < low[G[v][i].t])
          bridge.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
      } else if (G[v][i].t != p) {
        low[v] = min(low[v], ord[G[v][i].t]);
      }
    }
    if (p == -1 && ct > 1)
      isArticulation = true;
    if (isArticulation)
      arti.push_back(v);
  };
  int k = 0;
  rep(i, G.n) {
    if (!vis[i])
      dfs(i, -1, k);
  }
  sort(arti.begin(), arti.end());
  return arti;
}
// 閉路パスを一つ返す
vi close_path(digraph<> &g) {
  int n = g.n;
  vi state(n);
  vi path;
  rep(i, n) if (!state[i]) {
    if (fix([&](auto dfs, int v) -> bool {
          if (state[v]) {
            if (state[v] == 1) {
              path.erase(path.begin(), find(path.begin(), path.end(), v));
              return true;
            }
            return false;
          }
          path.push_back(v);
          state[v] = 1;
          forg(gi, g[v]) {
            if (dfs(t))
              return true;
          }
          state[v] = -1;
          path.pop_back();
          return false;
        })(i)) {
      return path;
    }
  }
  return vi();
}
vi close_path_min(digraph<> &g) {
  int n = g.n;
  vvi(dis, n);
  rep(i, n) dis[i] = dijkstra(g, i, linf);
  int mind = linf;
  int f = 0, t = 0;
  rep(i, n) {
    rep(j, n) {
      if (i == j)
        continue;
      if (chmi(mind, dis[i][j] + dis[j][i])) {
        f = i;
        t = j;
      }
    }
  }
  vi path;
  auto add = [&](int f, int t) {
    int now = f;
    while (now != t) {
      rep(i, n) {
        if (dis[now][i] == 1 && dis[f][i] + dis[i][t] == dis[f][t]) {
          path.push_back(i);
          now = i;
          break;
        }
      }
    }
  };
  add(f, t);
  add(t, f);
  return path;
}
// iを含む最短閉路 https://atcoder.jp/contests/abc022/tasks/abc022_c
/*閉路が1つしかない場合、その閉路に含まれる頂点を1としたvectorを返す*/;
template <class T> vi get_close1(digraph<T> &g) {
  int n = g.n;
  queue<int> q;
  vi d = outdegree(g);
  vi res(n, 1);
  rep(i, n) {
    if (d[i] == 0) {
      q += i;
      res[i] = 0;
    }
  }
  auto rg = rev(g);
  while (q.size()) {
    auto now = q.front();
    q.pop();
    forg(gi, rg[now]) {
      if (--d[t] == 0) {
        q += t;
        res[t] = 0;
      }
    }
  }
  return res;
}

//@アルゴリズム
template <class T> int krus(undigraph<T> &g) {
  int res = 0;
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e.c;
    }
  }
  return res;
}
template <class T> vector<edge_<T>> krus_ed(undigraph<T> &g) {
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  vector<edge_<T>> res;
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res.push_back(e);
    }
  }
  return res;
}
template <class T> tree<T> krus_tr(undigraph<T> &g) {
  tree<T> res(g.n);
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res.add(e.f, e.t);
    }
  }
  return res;
}
template <class T> int krus(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  int res = 0;
  unionfind uf(n);
  auto E = g;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e.c;
    }
  }
  return res;
}
template <class T> vector<edge_<T>> krus_ed(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  vector<edge_<T>> res;
  unionfind uf(n);
  auto E = g;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e;
    }
  }
  return res;
};
template <class T> vi krus_i(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  vi res;
  unionfind uf(n);
  auto E = g;
  sort(E);
  int i = 0;
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += i;
    }
    i++;
  }
  return res;
}
//@実験
digraph<> rang_di(int n, int m, bool zibun = 0, bool taju = 0) {
  umapp was;
  digraph<> g(n);
  was[mp(-1, -2)] = 1;
  while (m) {
    int f = -1, t = -2;
    while (f < 0 || (!taju && was[mp(f, t)])) {
      f = rand(0, n - 1);
      t = rand(0, n - 1);
      if (!zibun && f == t)
        f = -1;
    }
    g.add(f, t);
    was[mp(f, t)] = 1;
    m--;
  }
  return g;
}
digraph<> perfect_di(int n, bool zibun = 0) {
  digraph<> g(n);
  rep(i, n) {
    rep(j, n) {
      if (!zibun && i == j)
        con;
      g.add(i, j);
    }
  }
  return g;
}
undigraph<> rang_un(int n, int m, bool zibun = 0, bool taju = 0) {
  umapp was;
  undigraph<> g(n);
  was[mp(-1, -2)] = 1;
  while (m) {
    int f = -1, t = -2;
    while (f < 0 || (!taju && was[mp(min(f, t), max(f, t))])) {
      f = rand(0, n - 1);
      t = rand(0, n - 1);
      if (!zibun && f == t)
        f = -1;
    }
    g.add(f, t);
    was[mp(min(f, t), max(f, t))] = 1;
    m--;
  }
  return g;
}
undigraph<> perfect_un(int n, bool zibun = 0) {
  undigraph<> g(n);
  rep(i, n) {
    rep(j, i, n) {
      if (!zibun && i == j)
        con;
      g.add(i, j);
    }
  }
  return g;
}
/*頂点数がkの木を一つ返す サイズが0の木が帰ったら終了*/
tree<int> next_tree(int k) {
  assert(2 <= k && k < 11);
  static str name;
  static ifstream ina;
  static int rem;
  static vp edges;
  static int pk = -1; /*前回見たk*/
  if (pk != k) {
    if (~pk)
      ina.close();
    edges.clear();
    pk = k;
    name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\trees_sizek\\nazeka6.txt"
                    : "C:\\Users\\kaout\\Desktop\\trees_sizek\\tree_size" +
                          tos(k) + ".txt";
    ina = ifstream(name);
    rem = pow(k, k - 2); /*Cayleyの定理*/
    rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
    pk = k;
  }
  tree<int> g(k);
  if (rem == 0) {
    g.resize(0);
    return g;
  }
  int m;
  ina >> m;
  while (m) {
    int lb = lbit(m);
    int id = log2(lb);
    g.add(edges[id].first, edges[id].second);
    m ^= lb;
  }
  rem--;
  return g;
}
undigraph<int> next_undi(int k) {
  assert(2 <= k && k < 9);
  static str name;
  static ifstream ina;
  static int rem;
  static vp edges;
  static vi lims = {-1, -1, 1, 4, 38, 728, 26704, 1866256};
  static int pk = -1; /*前回見たk*/
  if (pk != k) {
    if (~pk)
      ina.close();
    edges.clear();
    pk = k;
    name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\undi_sizek\\roku.txt"
                    : "C:\\Users\\kaout\\Desktop\\undi_sizek\\undi_size" +
                          tos(k) + ".txt";
    ina = ifstream(name);
    rem = lims[k];
    rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
    pk = k;
  }
  undigraph<int> g(k);
  if (rem == 0) {
    g.resize(0);
    return g;
  }
  int m;
  ina >> m;
  while (m) {
    int lb = lbit(m);
    int id = log2(lb);
    g.add(edges[id].first, edges[id].second);
    m ^= lb;
  }
  rem--;
  return g;
}
vector<tree<int>> trees(int k) {
  vector<tree<int>> res;
  while (1) {
    tree<int> g = next_tree(k);
    if (sz(g) == 0)
      break;
    res.push_back(g);
  }
  return res;
}
vector<undigraph<int>> undis(int k) {
  vector<undigraph<int>> res;
  while (1) {
    undigraph<int> g = next_undi(k);
    if (sz(g) == 0)
      break;
    res.push_back(g);
  }
  return res;
}
template <class T> vector<vector<int>> table(graph<T> &g, int init_value) {
  vvi(res, g.n, g.n, init_value);
  rep(i, g.n) {
    forg(gi, g[i]) { res[i][t] = c; }
  }
  return res;
}
// type,idが使いたい場合はgraty
/*@formatter:on*/

namespace mint_china { /*@formatter:off*/
ll minv(ll a, ll m) {
  ll u = 0, v = 1;
  while (a != 0) {
    ll t = m / a;
    m -= t * a;
    swap(a, m);
    u -= t * v;
    swap(u, v);
  }
  assert(m == 1);
  return u;
}
ll garner(const vector<ll> &x, vector<ll> mods, ll mod = 0) {
  mods.emplace_back(mod);
  int n = sz(x);
  vector<ll> coeff; /* coeff[i]v_i*/
  vector<ll> constants;
  if (mod) {
    coeff.assign(n + 1, 1);
    constants.assign(n + 1, 0);
  } else {
    coeff.assign(n, 1);
    constants.assign(n, 0);
  }
  int nj = n + !!mod;
  for (size_t i = 0; i < n; i++) {
    ll v = (x[i] - constants[i]) * minv(coeff[i], mods[i]) % mods[i];
    if (v < 0)
      v += mods[i];
    for (size_t j = i + 1; j < nj; j++) {
      constants[j] = (constants[j] + coeff[j] * v) % mods[j];
      coeff[j] = (coeff[j] * mods[i]) % mods[j];
    }
  }
  return constants.back();
}
bool to_disjoint(vi &vs, vi &ms) {
  vector<int> primes;
  int maxm = *max_element(ms.begin(), ms.end());
  int lim = sqrt(maxm);
  vb p(lim + 1);
  for (int i = 2; i <= lim; i++) {
    if (p[i])
      continue;
    primes.eb(i);
    for (int j = i * i; j <= lim; j += i)
      p[j] = true;
  }
  for (int m : ms) {
    for (int p : primes)
      while (m % p == 0)
        m /= p;
    if (m != 1)
      primes.emplace_back(m);
  }
  int n = sz(ms);
  for (int p : primes) {
    vp ps;
    for (int i = 0; i < n; i++) {
      if (ms[i] % p == 0) {
        int lg = 0;
        while (ms[i] % p == 0)
          ms[i] /= p, lg++;
        ps.eb(lg, i);
      }
    }
    if (ps.size() < 1)
      continue;
    sort(ps);
    int base = vs[ps.back().second];
    for (auto d : ps) {
      if ((vs[d.second] - base) % p)
        return false;
      if (d.second == ps.back().second)
        for (int i = 0; i < d.first; i++)
          ms[d.second] *= p;
    }
  }
  return true;
}
int extGCD(int a, int b, int &x0, int &x1) {
  x0 = 1, x1 = 0;
  int y0 = 0, y1 = 1;
  while (b != 0) {
    int q = a / b;
    int r = a % b;
    int x2 = x0 - q * x1;
    int y2 = y0 - q * y1;
    a = b;
    b = r;
    x0 = x1;
    x1 = x2;
    y0 = y1;
    y1 = y2;
  }
  return a;
}
// 答えを x ≡ r (mod. M) として、{r, M} をリターン, 存在しない場合は {0, -1}
// をリターン
P ChineseRem(const vi &b, const vi &m) {
  int r = 0, M = 1;
  for (int i = 0; i < (int)b.size(); ++i) {
    int p, q;
    int d = extGCD(M, m[i], p, q); /* p is inv of M/d (mod. m[i]/d)*/
    if ((b[i] - r) % d != 0)
      return make_pair(0, -1);
    long long tmp = (b[i] - r) / d * p % (m[i] / d);
    r += M * tmp;
    M *= m[i] / d;
  }
  return make_pair(mod(r, M), M);
}
int china_m_r_mod_dj(vi &ms, vi &rs, int mod = 0,
                     int disjoint = -3) { /*中国余剰定理*/
  if (mod == 0) {
    bool exist_non_zero = false;
    for (int i = 0; i < sz(rs); ++i) {
      if (rs[i])
        exist_non_zero = true;
    }
    P res = ChineseRem(rs, ms);
    if (res.second == -1)
      return -1;
    else if (exist_non_zero)
      return res.first;
    else
      return res.second;
  } else {
    if (disjoint != -3 && !to_disjoint(rs, ms))
      return -1;
    int allzero = 1;
    ll ans = 1;
    int n = sz(ms);
    rep(i, n) {
      rs[i] = rs[i] % ms[i];
      if (rs[i] != 0)
        allzero = 0;
    }
    if (allzero) {
      if (mod)
        rep(i, n) ans = ans * ms[i] % mod;
      else
        rep(i, n) ans = ans * ms[i];
      return ans;
    }
    return garner(rs, ms, mod);
  }
}
// 基本chinaを使えばいい 答えが無ければ-
// m r
constexpr int MOD = 1000000007;
constexpr int MOE = 1000000009;
/*@formatter:on*/
struct mint {
  int X[2];
  mint() { X[0] = X[1] = 0; }
  mint(int a) {
    if (a < 0)
      X[0] = (a % MOD) + MOD, X[1] = (a % MOE) + MOE;
    else
      X[0] = a % MOD, X[1] = a % MOE;
  }
  mint &operator+=(mint that) {
    X[0] = (X[0] + that.X[0]) % MOD;
    X[1] = (X[1] + that.X[1]) % MOE;
    return *this;
  }
  mint &operator-=(mint that) {
    X[0] = (X[0] + MOD - that.X[0]) % MOD;
    X[1] = (X[1] + MOE - that.X[1]) % MOE;
    return *this;
  }
  mint &operator*=(mint that) {
    X[0] = (X[0] * that.X[0]) % MOD;
    X[1] = (X[1] * that.X[1]) % MOE;
    return *this;
  }
  mint &operator/=(mint that) { return *this *= that.inverse(); }
  mint operator-() {
    mint res = *this;
    if (X[0])
      res.X[0] = MOD - X[0];
    if (X[1])
      res.X[1] = MOE - X[1];
    return res;
  }
  friend ostream &operator<<(ostream &out, mint m) { return out << (int)m; }
  mint inverse() {
    mint ret;
    {
      int a = X[0], b = MOD, u = 1, v = 0;
      while (b) {
        int t = a / b;
        a -= t * b;
        u -= t * v;
        swap(a, b);
        swap(u, v);
      }
      if (u < 0)
        u = (u + MOD);
      ret.X[0] = (u);
    }
    {
      int a = X[1], b = MOE, u = 1, v = 0;
      while (b) {
        int t = a / b;
        a -= t * b;
        u -= t * v;
        swap(a, b);
        swap(u, v);
      }
      if (u < 0)
        u = (u + MOE);
      ret.X[1] = u;
    }
    return ret;
  }
  operator int() const {
    vi ms = {MOD, MOE};
    vi rs = {X[0], X[1]};
    return china_m_r_mod_dj(ms, rs);
  }
  template <class T> mint &operator+=(T that) { return operator+=((mint)that); }
  template <class T> mint &operator-=(T that) { return operator-=((mint)that); }
  template <class T> mint &operator*=(T that) { return operator*=((mint)that); }
  template <class T> mint &operator/=(T that) { return operator/=((mint)that); }
  mint operator+(mint that) { return mint(*this) += that; }
  mint operator-(mint that) { return mint(*this) -= that; }
  mint operator*(mint that) { return mint(*this) *= that; }
  mint operator/(mint that) { return mint(*this) /= that; }
  template <class T> mint operator+(T that) {
    return mint(*this) += (mint)that;
  }
  template <class T> mint operator-(T that) {
    return mint(*this) -= (mint)that;
  }
  template <class T> mint operator*(T that) {
    return mint(*this) *= (mint)that;
  }
  template <class T> mint operator/(T that) {
    return mint(*this) /= (mint)that;
  }
  //        bool operator==(mint that) const { return x == that.x && y ==
  //        that.y; }
  //        //重い
  //        bool operator==(signed that) const { return x == (mint) that; }
  //        bool operator!=(mint that) const { return !(x == that); }
  //        bool operator<(mint that) const { return (int) x < (int) that; }
  //        bool operator<=(mint that) const { return (int) x <= (int) that; }
  //        bool operator>(mint that) const { return (int) x > (int) that; }
  //        bool operator>=(mint that) const { return (int) x >= (int) that; }
};
istream &operator>>(istream &i, mint &a) {
  int v;
  i >> v;
  a = mint(v);
  return i;
}
typedef vector<mint> vm;
//    vector<mint> fac, finv;
int mint_len = 1400000; // 既に変更されていたら変えない
mint fac[1400000], finv[1400000];
struct setmod {
  setmod() {
    //            if (mint_len >= MOD - 1)mint_len = MOD - 1;
    //            if (mint_len >= MOE - 1)mint_len = MOE - 1;
    //            fac = vector<mint>(mint_len + 1);
    //            finv = vector<mint>(mint_len + 1);
    fac[0] = 1;
    rep(i, 1, mint_len + 1) { fac[i] = fac[i - 1] * i; }
    finv[mint_len] = (mint)1 / fac[mint_len];
    rer(i, mint_len, 1) { finv[i - 1] = finv[i] * i; }
  }
} setmodv;
mint com(int a, int b) {
  if (a < 0)
    return 0;
  if (b < 0 || b > a)
    return 0;
  return fac[a] * finv[a - b] * finv[b];
}
mint hom(int a, int b) { return com(a + b - 1, b); }
template <typename T, typename U> mint mpow(const T a, const U b) {
  assert(b >= 0);
  mint x = a, res = 1;
  U p = b;
  while (p > 0) {
    if (p & 1)
      (res *= x);
    x *= x;
    p >>= 1;
  }
  return res;
} /*@formatter:on*/
using PM = pair<mint, mint>;
using vm = vector<mint>;
#define vvm(...)                                                               \
  o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(mint, __VA_ARGS__)
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
} // namespace mint_china
//!!!答えが負になってはいけない
using mint = mint_china::mint;

void solve() {
  in(N);
  tree<> g(2 * k5);
  g.ing(N, N - 1);
  in(M);
  dna2d(U, V, M);
  vi in(M);
  fora(i, u, v, U, V) {       /*@formatter:off*/
    fora_init(i, u, v, U, V); /*@formatter:on*/
    auto D = g.pathe(u, v);
    in[i] = bit(D);
  }
  deb2(in);
  mint res = 0;
  rep(mas, bit(M)) {
    int use = 0;
    rep(i, M) {
      if (bget(mas, i))
        use |= in[i];
    }
    deb2(mas);
    deb2(use);
    int ziyu = N - 1;
    ziyu -= bcou(use);
    if ((bcou(mas) % 2) == 0) {
      res += powi(2, ziyu);
    } else {
      res -= powi(2, ziyu);
    }
  }
  out(res);
}

auto my(ll n, vi &a) { return 0; }

auto sister(ll n, vi &a) {
  ll ret = 0;
  return ret;
}

signed main() {
  solve();

#define arg n, a
#ifdef _DEBUG
  bool bad = 0;
  for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
    ll n = rand(1, 8);
    vi a = ranv(n, 1, 10);
    auto myres = my(arg);
    auto res = sister(arg);
    ok = myres == res;
    if (!ok) {
      out(arg);
      cerr << "AC : " << res << endl;
      cerr << "MY  : " << myres << endl;
      bad = 1;

      break;
    }
  }
  if (!bad) {
    //        cout << "完璧 : solveを書き直そう" << endl;
    //        cout << "     : そして、solve()を呼び出すのだ" << endl;
    //        cout << "     : cin>>n; na(a,n);も忘れるな" << endl;
  }
  if (sz(message)) {
    cerr << "****************************" << endl;
    cerr << message << endl;
    cerr << "****************************" << endl;
  }
#endif
  return 0;
};


Fixed submission:
// #undef _DEBUG
// #pragma GCC optimize("Ofast")
// 不動小数点の計算高速化
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long // todo 消したら動かない intの代わりにsignedを使う
#define ll long long
auto start_time = system_clock::now();
auto past_time = system_clock::now();

#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name

/*@formatter:off*/
//[-n, n)にアクセスできる
// また、外部関数resizeに渡せる
// sizeは[-n, n)でnを返す
template <class T> class mvec {
  vector<T> v;
  int n;

public:
  mvec() : n(0), v(0) {}
  mvec(int n) : n(n), v(n * 2) {}
  mvec(int n, T val) : n(n), v(n * 2, val) {}
  auto &operator[](int i) { return v[i + n]; }
  auto size() { return n; }
  void resize(int sn) {
    assert(n == 0);
    n = sn;
    v.resize(sn * 2);
  }
  auto begin() { return v.begin(); }
  auto rbegin() { return v.rbegin(); }
  auto end() { return v.end(); }
  auto rend() { return v.rend(); }
};
//[]でboolは参照を返さないため特殊化が必要
template <> struct mvec<bool> {
  vector<bool> v;
  int n;
  mvec() : n(0), v(0) {}
  mvec(int n) : n(n), v(n * 2) {}
  mvec(int n, bool val) : n(n), v(n * 2, val) {}
  auto operator[](int i) { return v[i + n]; }
  auto size() { return v.size(); }
  void resize(int sn) {
    assert(n == 0);
    n = sn;
    v.resize(sn * 2);
  }
  auto begin() { return v.begin(); }
  auto rbegin() { return v.rbegin(); }
  auto end() { return v.end(); }
  auto rend() { return v.rend(); }
};
template <class T> ostream &operator<<(ostream &os, mvec<T> &a) {
  int spa = 3;
  for (auto &&v : a) {
    spa = max(spa, (int)(to_string(v).size()) + 1);
  }
  int n = (int)a.size();
  os << endl;
  for (int i = -n; i < n; i++) {
    int need = spa - ((int)to_string(i).size());
    if (i == -n) {
      need -= min(need, spa - ((int)to_string(a[i]).size()));
    }
    while (need--) {
      os << " ";
    }
    os << i;
  }
  os << endl;
  int i = -n;
  for (auto &&v : a) {
    int need = spa - ((int)to_string(v).size());
    if (i == -n) {
      need -= min(need, spa - ((int)to_string(i).size()));
    }
    while (need--) {
      os << " ";
    }
    os << v;
    i++;
  }
  return os;
}
#define mv mvec
#define MV mvec
using mvi = mvec<ll>;
using mvb = mvec<bool>;
using mvs = mvec<string>;
using mvd = mvec<double>;
using mvc = mvec<char>;

#define mvvt0(t) mvec<mvec<t>>
#define mvvt1(t, a) mvec<mvec<t>> a
#define mvvt2(t, a, b) mvec<mvec<t>> a(b)
#define mvvt3(t, a, b, c) mvec<mvec<t>> a(b, mvec<t>(c))
#define mvvt4(t, a, b, c, d) mvec<mvec<t>> a(b, mvec<t>(c, d))
#define mvvi(...)                                                              \
  over4(__VA_ARGS__, mvvt4, mvvt3, mvvt2, mvvt1, mvvt0)(ll, __VA_ARGS__)

template <typename T> mvec<T> make_mv(size_t a) { return mvec<T>(a); }
template <typename T, typename... Ts> auto make_mv(size_t a, Ts... ts) {
  return mvec<decltype(make_mv<T>(ts...))>(a, make_mv<T>(ts...));
}
#define mvni(name, ...) auto name = make_mv<ll>(__VA_ARGS__)

#ifdef _DEBUG
string message;
// https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template <class T, class A = std::allocator<T>>
struct debtor : std::vector<T, A> {
  using std::vector<T, A>::vector;
  template <class U> int deb_v(U a, int v) { return v; }
  template <class U> int deb_v(debtor<U> &a, int v = 0) {
    cerr << a.size() << " ";
    return deb_v(a.at(0), v + 1);
  }
  template <class U> void deb_o(U a) { cerr << a << " "; }
  template <class U> void deb_o(debtor<U> &a) {
    for (int i = 0; i < min((int)a.size(), 15ll); i++) {
      deb_o(a[i]);
    }
    if ((int)a.size() > 15) {
      cerr << "...";
    }
    cerr << endl;
  }
  typename std::vector<T>::reference
  operator[](typename std::vector<T>::size_type n) {
    if (n < 0 || n >= (int)this->size()) {
      int siz = (int)this->size();
      cerr << "vector size = ";
      int dim = deb_v((*this));
      cerr << endl;
      cerr << "out index at  " << n << endl;
      cerr << endl;
      if (dim <= 2) {
        deb_o((*this));
      }
      exit(0);
    }
    return this->at(n);
  }
};
// #define vector debtor
// 区間削除は出来ない
template <class T> struct my_pbds_tree {
  set<T> s;
  auto begin() { return s.begin(); }
  auto end() { return s.end(); }
  auto rbegin() { return s.rbegin(); }
  auto rend() { return s.rend(); }
  auto empty() { return s.empty(); }
  auto size() { return s.size(); }
  void clear() { s.clear(); }
  template <class U> void insert(U v) { s.insert(v); }
  template <class U> void operator+=(U v) { insert(v); }
  template <class F> auto erase(F v) { return s.erase(v); }
  template <class U> auto find(U v) { return s.find(v); }
  template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
  template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
  auto find_by_order(ll k) {
    auto it = s.begin();
    for (ll i = 0; i < k; i++)
      it++;
    return it;
  }
  auto order_of_key(ll v) {
    auto it = s.begin();
    ll i = 0;
    for (; it != s.end() && *it < v; i++)
      it++;
    return i;
  }
};
#define pbds(T) my_pbds_tree<T>
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
  unordered_map<T, U> m;
  my_unordered_map(){};
  auto begin() { return m.begin(); }
  auto end() { return m.end(); }
  auto cbegin() { return m.cbegin(); }
  auto cend() { return m.cend(); }
  template <class V> auto erase(V v) { return m.erase(v); }
  void clear() {
    m.clear();
  } /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
  template <class V> auto find(V v) { return m.find(v); }
  template <class V> auto &operator[](V n) { return m[n]; }
};
#define unordered_map my_unordered_map
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umapu unordered_map<uint64_t, ll>
#define umapip unordered_map<ll, P>

#else
#define endl '\n'
// umapはunorderd_mapになる
// umapiはgp_hash_table

// find_by_order(k) k番目のイテレーター
// order_of_key(k)  k以上が前から何番目か
#define pbds(U)                                                                \
  __gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
                   __gnu_pbds::tree_order_statistics_node_update>

#define umapi __gnu_pbds::gp_hash_table<ll, ll, xorshift>
#define umapp __gnu_pbds::gp_hash_table<P, ll, xorshift>
#define umapu __gnu_pbds::gp_hash_table<uint64_t, ll, xorshift>
#define umapip __gnu_pbds::gp_hash_table<ll, P, xorshift>

#endif
/*@formatter:on*/
struct xorshift {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(std::pair<ll, ll> x) const {
    ll v = ((x.first) << 32) | x.second;
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(v + FIXED_RANDOM);
  }
};
/*@formatter:off*/
template <class U, class L>
void operator+=(
    __gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
                     __gnu_pbds::tree_order_statistics_node_update> &s,
    L v) {
  s.insert(v);
}
// 衝突対策
#define ws ws_

template <class A, class B, class C> struct T2 {
  A f;
  B s;
  C t;
  T2() { f = 0, s = 0, t = 0; }
  T2(A f, B s, C t) : f(f), s(s), t(t) {}
  bool operator<(const T2 &r) const {
    return f != r.f   ? f < r.f
           : s != r.s ? s < r.s
                      : t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
                                    r.s : t > r.t; 大きい順 */
  }
  bool operator>(const T2 &r) const {
    return f != r.f   ? f > r.f
           : s != r.s ? s > r.s
                      : t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
                                    r.s : t > r.t; 小さい順 */
  }
  bool operator==(const T2 &r) const {
    return f == r.f && s == r.s && t == r.t;
  }
  bool operator!=(const T2 &r) const {
    return f != r.f || s != r.s || t != r.t;
  }
};
template <class A, class B, class C, class D> struct F2 {
  A a;
  B b;
  C c;
  D d;
  F2() { a = 0, b = 0, c = 0, d = 0; }
  F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
  bool operator<(const F2 &r) const {
    return a != r.a   ? a < r.a
           : b != r.b ? b < r.b
           : c != r.c ? c < r.c
                      : d < r.d; /*    return a != r.a ? a > r.a : b != r.b ? b
                                    > r.b : c != r.c ? c > r.c : d > r.d;*/
  }
  bool operator>(const F2 &r) const {
    return a != r.a   ? a > r.a
           : b != r.b ? b > r.b
           : c != r.c ? c > r.c
                      : d > r.d; /*        return a != r.a ? a < r.a : b != r.b
                                    ? b < r.b : c != r.c ? c < r.c : d < r.d;*/
  }
  bool operator==(const F2 &r) const {
    return a == r.a && b == r.b && c == r.c && d == r.d;
  }
  bool operator!=(const F2 &r) const {
    return a != r.a || b != r.b || c != r.c || d != r.d;
  }
  ll operator[](ll i) {
    assert(i < 4);
    return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
  }
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
T mt(ll a, ll b, ll c) { return T(a, b, c); }
F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }

//@マクロ省略系 型,構造
#define double long double
// #define pow powl
using dou = double;
const double eps = 1e-9;
// 基本コメントアウト
/*
struct epsdou {    double v;    epsdou(double v = 0) : v(v) {}    template<class
T> epsdou &operator+=(T b) {        v += (double) b;        return (*this);    }
template<class T> epsdou &operator-=(T b) {        v -= (double) b; return
(*this);    }    template<class T> epsdou &operator*=(T b) {        v *=
(double) b;        return (*this);    }    template<class T> epsdou
&operator/=(T b) {        v /= (double) b;        return (*this);    }    epsdou
operator+(epsdou b) { return v + (double) b; }    epsdou operator-(epsdou b) {
return v - (double) b; }    epsdou operator*(epsdou b) { return v * (double) b;
}    epsdou operator/(epsdou b) { return v / (double) b; }    epsdou operator-()
const { return epsdou(-v); }    template<class T> bool operator<(T b) { return v
< (double) b; }    template<class T> bool operator>(T b) { return v > (double)
b; }    template<class T> bool operator==(T b) { return fabs(v - (double) b) <=
eps; }    template<class T> bool operator<=(T b) { return v < (double) b ||
fabs(v - b) <= eps; }    template<class T> bool operator>=(T b) { return v >
(double) b || fabs(v - b) <= eps; }    operator double() { return v; }};istream
&operator>>(istream &iss, epsdou &a) {    iss >> a.v;    return iss;}ostream
&operator<<(ostream &os, epsdou &a) {    os << a.v;    return os;} #define
eps_conr_t(o) template<class T> epsdou operator o(T b, epsdou a){return a.v o
(dou)b;} #define eps_conl_t(o) template<class T> epsdou operator o(epsdou a, T
b){return a.v o (dou)b;}
eps_conl_t(+)eps_conl_t(-)eps_conl_t(*)eps_conl_t(/)eps_conr_t(+)eps_conr_t(-)eps_conr_t(*)eps_conr_t(/)
#undef double
#define double epsdou
*/

#define ull unsigned long long
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using mvp = mvec<P>;
using mvt = mvec<T>;
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()

#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define upd update
#define sstream stringstream

#define maxq 1
#define minq -1

#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam1(ret) [&](auto &v) { return ret; }
#define lam2(v, ret) [&](auto &v) { return ret; }
#define lam(...) over2(__VA_ARGS__, lam2, lam1)(__VA_ARGS__)
#define lamr(right) [&](auto &p) { return p right; }

// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;

// #define V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>> a
#define vvt2(t, a, b) vector<vector<t>> a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b, vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b, vector<t>(c, d))

#define vvi(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...)                                                               \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
#define vv(type, ...)                                                          \
  over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(type, __VA_ARGS__)

template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define vn(type, name, ...) auto name = make_v<type>(__VA_ARGS__)

#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
// 任意のマクロサポート用 使う度に初期化する
int index_, v1_, v2_, v3_;

template <class T> struct pq {
  priority_queue<T, vector<T>, greater<T>> q; /*小さい順*/
  T su = 0;
  void clear() {
    q = priority_queue<T, vector<T>, greater<T>>();
    su = 0;
  }
  void operator+=(T v) {
    su += v;
    q.push(v);
  }
  T sum() { return su; }
  T top() { return q.top(); }
  void pop() {
    su -= q.top();
    q.pop();
  }
  T poll() {
    T ret = q.top();
    su -= ret;
    q.pop();
    return ret;
  }
  ll size() { return q.size(); }
};
template <class T> struct pqg {
  priority_queue<T> q; /*大きい順*/
  T su = 0;
  void clear() {
    q = priority_queue<T>();
    su = 0;
  }
  void operator+=(T v) {
    su += v;
    q.push(v);
  }
  T sum() { return su; }
  T top() { return q.top(); }
  void pop() {
    su -= q.top();
    q.pop();
  }
  T poll() {
    T ret = q.top();
    su -= ret;
    q.pop();
    return ret;
  }
  ll size() { return q.size(); }
};
#define pqi pq<ll>
#define pqgi pqg<ll>
// マクロ 繰り返し
// ↓@オーバーロード隔離

#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
// 逆順 閉区間
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
// ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J)                                                      \
  i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K)                                                \
  i = (j + 1 == J && k + 1 == K) ? i + 1 : i,                                  \
  j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j,                             \
  k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L)                                          \
  i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i,                    \
  j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j,               \
  k = (l + 1 == L ? (k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M)                                    \
  i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i,      \
  j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, \
  k = (l + 1 == L && m + 1 == M ? (k + 1 == K ? 0 : k + 1) : k),               \
  l = m + 1 == M ? l + 1 == L ? 0 : l + 1 : l, m = m + 1 == M ? 0 : m + 1

#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J)                                                     \
  for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K)                                               \
  for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L)                                         \
  for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I;              \
       nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M)                                  \
  for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I;  \
       nex_ind5(i, j, k, l, m, J, K, L, M))

// i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)

template <class T>
void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) {
  while (1) {
    j++;
    if (j >= J) {
      j = 0;
      i++;
      if (i < I) {
        J = (int)s[i].size();
      }
    }
    if (i >= I || J)
      return;
  }
}
template <class T>
void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K,
               vector<vector<vector<T>>> &s) {
  while (1) {
    k++;
    if (k >= K) {
      k = 0;
      j++;
      if (j >= J) {
        j = 0;
        i++;
        if (i >= I)
          return;
      }
    }
    J = (int)s[i].size();
    K = (int)s[i][j].size();
    if (J && K)
      return;
  }
}

#define repv_2(i, a) repss2(i, sz(a))
// 正方形である必要はない
// 直前を持つのとどっちが早いか
#define repv_3(i, j, a)                                                        \
  for (int I = (int)a.size(), J = (int)a[0].size(), i = 0, j = 0; i < I;       \
       nex_repv2(i, j, I, J, a))
// 箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a)                                                     \
  for (int I = (int)a.size(), J = (int)a[0].size(), K = (int)a[0][0].size(),   \
           i = 0, j = 0, k = 0;                                                \
       i < I; nex_repv3(i, j, k, I, J, K, a))
#define repv_5(i, j, k, l, a)                                                  \
  repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a)                                               \
  repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]),         \
          sz(a[0][0][0][0]))

template <typename T> struct has_rbegin_rend {
private:
  template <typename U>
  static auto check(U &&obj)
      -> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});
  static std::false_type check(...);

public:
  static constexpr bool value = decltype(check(std::declval<T>()))::value;
};
template <typename T>
constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template <typename Iterator> class Range {
public:
  Range(Iterator &&begin, Iterator &&end) noexcept
      : m_begin(std::forward<Iterator>(begin)),
        m_end(std::forward<Iterator>(end)) {}
  Iterator begin() const noexcept { return m_begin; }
  Iterator end() const noexcept { return m_end; }

private:
  const Iterator m_begin;
  const Iterator m_end;
};
template <typename Iterator>
static inline Range<Iterator> makeRange(Iterator &&begin,
                                        Iterator &&end) noexcept {
  return Range<Iterator>{std::forward<Iterator>(begin),
                         std::forward<Iterator>(end)};
}
template <typename T>
static inline decltype(auto)
makeReversedRange(const std::initializer_list<T> &iniList) noexcept {
  return makeRange(std::rbegin(iniList), std::rend(iniList));
}
template <typename T, typename std::enable_if_t<has_rbegin_rend_v<T>,
                                                std::nullptr_t> = nullptr>
static inline decltype(auto) makeReversedRange(T &&c) noexcept {
  return makeRange(std::rbegin(c), std::rend(c));
} /* rbegin(),
     rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/
template <typename T, typename std::enable_if<!has_rbegin_rend<T>::value,
                                              std::nullptr_t>::type = nullptr>
static inline void makeReversedRange(T &&) noexcept {
  static_assert(has_rbegin_rend<T>::value,
                "Specified argument doesn't have reverse iterator.");
}

#define form1(st)                                                              \
  for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form3(k, v, st)                                                        \
  for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form4(k, v, st, r)                                                     \
  for (auto &&form_it = st.begin(); form_it != st.end() && (*form_it).fi < r;  \
       ++form_it)
#define form5(k, v, st, l, r)                                                  \
  for (auto &&form_it = st.lower_bound(l);                                     \
       form_it != st.end() && (*form_it).fi < r; ++form_it)

#define fors1(st)                                                              \
  for (auto &&fors_it = st.begin(); fors_it != st.end(); ++fors_it)
#define fors2(v, st)                                                           \
  for (auto &&fors_it = st.begin(); fors_it != st.end(); ++fors_it)
#define fors3(v, st, r)                                                        \
  for (auto &&fors_it = st.begin(); fors_it != st.end() && (*fors_it) < r;     \
       ++fors_it)
#define fors4(v, st, l, r)                                                     \
  for (auto &&fors_it = st.lower_bound(l);                                     \
       fors_it != st.end() && (*fors_it) < r; ++fors_it)

#define forslr3(st, a, b)                                                      \
  for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b)                                                   \
  for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b)                                                \
  for (auto &&forslr_it = st.begin();                                          \
       forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b)                                             \
  for (auto &&forslr_it = st.lower_bound(l);                                   \
       forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)

template <class U> vector<U> to1d(vector<U> &a) { return a; }
template <class U> vector<U> to1d(vector<vector<U>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      res.push_back(a2);
  return res;
}
template <class U> vector<U> to1d(vector<vector<vector<U>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        res.push_back(a3);
  return res;
}
template <class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          res.push_back(a4);
  return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          for (auto &&a5 : a4)
            res.push_back(a5);
  return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {
  vector<U> res;
  for (auto &&a1 : a)
    for (auto &&a2 : a1)
      for (auto &&a3 : a2)
        for (auto &&a4 : a3)
          for (auto &&a5 : a4)
            for (auto &&a6 : a5)
              res.push_back(a6);
  return res;
}

#define fora_init_2(a, A) ;
#define fora_init_3(fora_i, a, A) auto &&a = A[fora_i];
#define fora_init_4(a, b, A, B)                                                \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];
#define fora_init_5(fora_i, a, b, A, B)                                        \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];
#define fora_init_6(a, b, c, A, B, C)                                          \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];
#define fora_init_7(fora_i, a, b, c, A, B, C)                                  \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];
#define fora_init_8(a, b, c, d, A, B, C, D)                                    \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];                                                        \
  auto &&d = D[fora_i];
#define fora_init_9(fora_i, a, b, c, d, A, B, C, D)                            \
  auto &&a = A[fora_i];                                                        \
  auto &&b = B[fora_i];                                                        \
  auto &&c = C[fora_i];                                                        \
  auto &&d = D[fora_i];
#define fora_init(...)                                                         \
  over9(__VA_ARGS__, fora_init_9, fora_init_8, fora_init_7, fora_init_6,       \
        fora_init_5, fora_init_4, fora_init_3, fora_init_2)(__VA_ARGS__)

#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B)                                                \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B)                                        \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C)                                          \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C)                                  \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D)                                    \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];                                                        \
  auto &&d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D)                            \
  auto &&a = A[forr_i];                                                        \
  auto &&b = B[forr_i];                                                        \
  auto &&c = C[forr_i];                                                        \
  auto &&d = D[forr_i];
#define forr_init(...)                                                         \
  over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6,       \
        forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)

#define forp_init(k, v, ...)                                                   \
  auto &&k = (*forp_it).fi;                                                    \
  auto &&v = (*forp_it).se;
#define form_init(k, v, ...)                                                   \
  auto &&k = (*form_it).fi;                                                    \
  auto &&v = (*form_it).se;
#define fors_init(v, ...) auto &&v = (*fors_it);

#define forlr_init(a, A, ngl, ngr)                                             \
  auto a = A[forlr_i];                                                         \
  auto prev = forlr_i ? A[forlr_i - 1] : ngl;                                  \
  auto next = forlr_i + 1 < rep2lim ? A[forlr_i + 1] : ngr;
#define forslr_init4(a, A, ngl, ngr)                                           \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr)                                        \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr)                                     \
  auto a = (*forslr_it);                                                       \
  auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl;        \
  auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init(...)                                                       \
  over6(__VA_ARGS__, forslr_init6, forslr_init5, forslr_init4)(__VA_ARGS__);

#define fora_2(a, A) for (auto &&a : A)
#define fora_3(fora_i, a, A) rep(fora_i, sz(A))
#define fora_4(a, b, A, B) rep(fora_i, sz(A))
#define fora_5(fora_i, a, b, A, B) rep(fora_i, sz(A))
#define fora_6(a, b, c, A, B, C) rep(fora_i, sz(A))
#define fora_7(fora_i, a, b, c, A, B, C) rep(fora_i, sz(A))
#define fora_8(a, b, c, d, A, B, C, D) rep(fora_i, sz(A))
#define fora_9(fora_i, a, b, c, d, A, B, C, D) rep(fora_i, sz(A))

#define forr_2(a, A) rer(forr_i, sz(A) - 1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A) - 1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)

// ↑@オーバーロード隔離

// rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
// char用のrep
#define repc(i, m, n) for (char i = m, repc3lim = n; i < repc3lim; ++i)
// i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__, reps5, reps4, reps3, reps2, )(__VA_ARGS__)
#define repss(...)                                                             \
  over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a,             \
         repss2)(__VA_ARGS__)
// vectorのindexを走査する
// repv(i,j,vvi)
#define repv(...)                                                              \
  over6(__VA_ARGS__, repv_6, repv_5, repv_4, repv_3, repv_2, )(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A) - 1; i >= 0; i--)
// repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)

#define fora(...)                                                              \
  over9(__VA_ARGS__, forr_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3,   \
        fora_2)(__VA_ARGS__)
#define forr(...)                                                              \
  over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3,   \
        forr_2)(__VA_ARGS__)

// #define forr(v, a) for(auto&& v : makeReversedRange(a))
// 参照を取らない
#define forv(a, b) for (auto a : to1d(b))

// インデックスを前後含めて走査
#define ring(i, s, len)                                                        \
  for (int i = s, prev = (s == 0) ? len - 1 : s - 1,                           \
           next = (s == len - 1) ? 0 : s + 1, cou = 0;                         \
       cou < len;                                                              \
       cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// 値と前後を見る
#define ringv(v, d)                                                            \
  index_ = 0;                                                                  \
  for (auto prev = d[sz(d) - 1], next = (int)d.size() > 1 ? d[1] : d[0],       \
            v = d[0];                                                          \
       index_ < sz(d); index_++, prev = v, v = next,                           \
            next = (index_ >= sz(d) - 1 ? d[0] : d[index_ + 1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i, sz(d))

#define form(...)                                                              \
  over5(__VA_ARGS__, form5, form4, form3, form2, form1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__, fors4, fors3, fors2, fors1)(__VA_ARGS__)
#define forslr(...)                                                            \
  over6(__VA_ARGS__, forslr6, forslr5, forslr4, forslr3)(__VA_ARGS__)
#define forp(k, v, st)                                                         \
  for (auto &&forp_it = st.begin(); forp_it != st.end(); ++forp_it)

// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const ll inf = (ll)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const dou dinf = (dou)linf * linf;
const char infc = '{';
const string infs = "{";
const double PI = 3.1415926535897932384626433832795029L;

// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()

constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの

// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
  size_t operator()(const std::pair<signed, signed> &x) const {
    return hash<ll>()(((ll)x.first << 32) | x.second);
  }
};
template <> class hash<std::pair<ll, ll>> {
public
    : /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
  size_t operator()(const std::pair<ll, ll> &x) const {
    return hash<ll>()(((ll)x.first << 32) | x.second);
  }
};
} // namespace std
// stream まとめ
/*@formatter:on*/
istream &operator>>(istream &iss, P &a) {
  iss >> a.first >> a.second;
  return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
  for (T &x : vec)
    iss >> x;
  return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
  os << p.fi << " " << p.se;
  return os;
}
ostream &operator<<(ostream &os, T p) {
  os << p.f << " " << p.s << " " << p.t;
  return os;
}
ostream &operator<<(ostream &os, F p) {
  os << p.a << " " << p.b << " " << p.c << " " << p.d;
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
  for (ll i = 0; i < vec.size(); ++i)
    os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  return os;
}

template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
  for (ll i = 0; i < vec.size(); ++i) {
    for (ll j = 0; j < vec[i].size(); ++j) {
      os << vec[i][j] << " ";
    }
    os << endl;
  }
  return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
  for (auto &&v : m)
    os << v;
  return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
  fora(v, s) { os << v << " "; }
  return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
  fora(v, a) os << v << " ";
  return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec) {
  rep(h, sz(vec)) {
    rep(w, sz(vec[0])) { os << vec[h][w]; }
    os << endl;
  }
  return os;
}
// template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>&
// a) {fora(v,a)os<<v<<endl;return os;}
/*@formatter:off*/
template <typename W, typename H> void resize(W &vec, const H head) {
  vec.resize(head);
}
template <typename W, typename H, typename... T>
void resize(W &vec, const H &head, const T... tail) {
  vec.resize(head);
  for (auto &v : vec)
    resize(v, tail...);
}
// template<typename W, typename H> void resize(vector<W> &vec, const H head) {
// vec.resize(head); } template<typename W, typename H, typename ... T> void
// resize(vector<W> &vec, const H &head, const T ... tail) {vec.resize(head);for
// (auto &v: vec)resize(v, tail...);}
template <typename T, typename F> bool all_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (!all_of2(v[i], f))
      return false;
  }
  return true;
}
template <typename T, typename F> bool any_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (any_of2(v[i], f))
      return true;
  }
  return false;
}
template <typename T, typename F> bool none_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool none_of2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (none_of2(v[i], f))
      return false;
  }
  return true;
}
template <typename T, typename F> bool find_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll find_if2(vector<T> &v, F f) {
  rep(i, sz(v)) {
    if (find_if2(v[i], f))
      return i;
  }
  return sz(v);
}
template <typename T, typename F> bool rfind_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll rfind_if2(vector<T> &v, F f) {
  rer(i, sz(v) - 1) {
    if (rfind_if2(v[i], f))
      return i;
  }
  return -1;
}
template <class T> bool contains(string &s, const T &v) {
  return s.find(v) != string::npos;
}
template <typename T> bool contains(vector<T> &v, const T &val) {
  return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(vector<T> &v, F f) {
  return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(vector<T> &vec, F f) {
  ll ret = 0;
  fora(v, vec) ret += count_if2(v, f);
  return ret;
}
template <typename T, typename F> void for_each2(T &v, F f) { f(v); }
template <typename T, typename F> void for_each2(vector<T> &vec, F f) {
  fora(v, vec) for_each2(v, f);
}
template <typename W> ll count_od(vector<W> &a) {
  return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(vector<W> &a) {
  return count_if2(a, [](ll v) { return !(v & 1); });
}
// 削除した後のvectorを返す
template <typename T, typename F> vector<T> erase_if2(vector<T> &v, F f) {
  vector<T> nv;
  rep(i, sz(v)) {
    if (!f(v[i])) {
      nv.push_back(v[i]);
    }
  }
  return nv;
}
template <typename T, typename F>
vector<vector<T>> erase_if2(vector<vector<T>> &v, F f) {
  vector<vector<T>> res;
  rep(i, sz(v)) { res[i] = erase_if2(v[i], f); }
  return res;
}
// all_of(A, %2);
// all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a, lamr(right))
#define all_of__3(a, v, siki) all_of2(a, [&](auto v) { return siki; })
#define all_of(...) over3(__VA_ARGS__, all_of__3, all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a, f)

#define any_of__2(a, right) any_of2(a, lamr(right))
#define any_of__3(a, v, siki) any_of2(a, [&](auto v) { return siki; })
#define any_of(...) over3(__VA_ARGS__, any_of__3, any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a, f)

#define none_of__2(a, right) none_of2(a, lamr(right))
#define none_of__3(a, v, siki) none_of2(a, [&](auto v) { return siki; })
#define none_of(...) over3(__VA_ARGS__, none_of__3, none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a, f)

#define find_if__2(a, right) find_if2(a, lamr(right))
#define find_if__3(a, v, siki) find_if2(a, [&](auto v) { return siki; })
#define find_if(...) over3(__VA_ARGS__, find_if__3, find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a, f)

#define rfind_if__2(a, right) rfind_if2(a, lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a, [&](auto v) { return siki; })
#define rfind_if(...) over3(__VA_ARGS__, rfind_if__3, rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a, f)

#define contains_if__2(a, right) contains_if2(a, lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a, [&](auto v) { return siki; })
#define contains_if(...)                                                       \
  over3(__VA_ARGS__, contains_if__3, contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a, f)

#define count_if__2(a, right) count_if2(a, lamr(right))
#define count_if__3(a, v, siki) count_if2(a, [&](auto v) { return siki; })
#define count_if(...) over3(__VA_ARGS__, count_if__3, count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a, f)

#define for_each__2(a, right)                                                  \
  do {                                                                         \
    fora(v, a) { v right; }                                                    \
  } while (0)
#define for_each__3(a, v, siki)                                                \
  do {                                                                         \
    fora(v, a) { siki; }                                                       \
  } while (0)
#define for_each(...) over3(__VA_ARGS__, for_each__3, for_each__2)(__VA_ARGS__)
#define for_each_f(a, f)                                                       \
  do {                                                                         \
    fora(v, a) { f(v); }                                                       \
  } while (0)

#define erase_if__2(a, right) erase_if2(a, lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a, [&](auto v) { return siki; })
#define erase_if(...) over3(__VA_ARGS__, erase_if__3, erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a, f)

#define entry_if__2(a, right) erase_if2(a, [&](auto v) { return !(v right); })
#define entry_if__3(a, v, siki) erase_if2(a, [&](auto v) { return !(siki); })
#define entry_if(...) over3(__VA_ARGS__, entry_if__3, entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) erase_if2(a, [&](auto v) { return !f(v); })

template <class T, class U, class W> void replace(vector<W> &a, T key, U v) {
  rep(i, sz(a)) if (a[i] == key) a[i] = v;
}
template <class T, class U, class W>
void replace(vector<vector<W>> &A, T key, U v) {
  rep(i, sz(A)) replace(A[i], key, v);
}
void replace(str &a, char key, str v) {
  if (v == "")
    a.erase(remove(all(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
  rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
  rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
void replace(str &a, str key, str v) {
  stringstream t;
  ll kn = sz(key);
  std::string::size_type Pos(a.find(key));
  ll l = 0;
  while (Pos != std::string::npos) {
    t << a.substr(l, Pos - l);
    t << v;
    l = Pos + kn;
    Pos = a.find(key, Pos + kn);
  }
  t << a.substr(l, sz(a) - l);
  a = t.str();
}
template <class T> bool includes(vector<T> &a, vector<T> &b) {
  vi c = a;
  vi d = b;
  sort(all(c));
  sort(all(d));
  return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
  return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
  return next_permutation(all(a));
}
void iota(vector<ll> &ve, ll s, ll n) {
  ve.resize(n);
  iota(all(ve), s);
}
vi iota(ll s, ll len) {
  vi ve(len);
  iota(all(ve), s);
  return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
  assert(sz(a) == sz(b)); /*stringを0で初期化できない  */
  vector<pair<A, B>> res;
  rep(i, sz(a)) res.eb(a[i], b[i]);
  return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
  a.resize(sz(p)), b.resize(sz(p));
  rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
  assert(sz(a) == sz(b) && sz(b) == sz(c));
  vector<T2<A, B, C>> res;
  rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
  return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
  vector<F2<A, B, C, D>> res;
  rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
  return res;
}
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
  fisiti,
  fisitd,
  fisdti,
  fisdtd,
  fdsiti,
  fdsitd,
  fdsdti,
  fdsdtd,
  fitisi,
  fitisd,
  fitdsi,
  fitdsd,
  fdtisi,
  fdtisd,
  fdtdsi,
  fdtdsd,
  sifiti,
  sifitd,
  sifdti,
  sifdtd,
  sdfiti,
  sdfitd,
  sdfdti,
  sdfdtd,
  sitifi,
  sitifd,
  sitdfi,
  sitdfd,
  sdtifi,
  sdtifd,
  sdtdfi,
  sdfdfd,
  tifisi,
  tifisd,
  tifdsi,
  tifdsd,
  tdfisi,
  tdfisd,
  tdfdsi,
  tdfdsd,
  tisifi,
  tisifd,
  tisdfi,
  tisdfd,
  tdsifi,
  tdsifd,
  tdsdfi,
  tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
  typedef pair<A, B> U;
  if (type == fisi)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
  else if (type == fisd)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
  else if (type == fdsi)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
  else if (type == fdsd)
    sort(all(a),
         [&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
  else if (type == sifi)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
  else if (type == sifd)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
  else if (type == sdfi)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
  else if (type == sdfd)
    sort(all(a),
         [&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
  if (type == fisi)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
  else if (type == fisd)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
  else if (type == fdsi)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
  else if (type == fdsd)
    sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
  else if (type == sifi)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
  else if (type == sifd)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
  else if (type == sdfi)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
  else if (type == sdfd)
    sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
  typedef F2<A, B, C, D> U;
  if (type == fisi)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
  else if (type == fisd)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
  else if (type == fdsi)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
  else if (type == fdsd)
    sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
  else if (type == sifi)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
  else if (type == sifd)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
  else if (type == sdfi)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
  else if (type == sdfd)
    sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
  if (type == 0)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
    });
  else if (type == 1)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
    });
  else if (type == 2)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
    });
  else if (type == 3)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
    });
  else if (type == 4)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
    });
  else if (type == 5)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
    });
  else if (type == 6)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
    });
  else if (type == 7)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
    });
  else if (type == 8)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
    });
  else if (type == 9)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
    });
  else if (type == 10)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
    });
  else if (type == 11)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
    });
  else if (type == 12)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
    });
  else if (type == 13)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
    });
  else if (type == 14)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
    });
  else if (type == 15)
    sort(all(a), [&](U l, U r) {
      return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
    });
  else if (type == 16)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
    });
  else if (type == 17)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
    });
  else if (type == 18)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
    });
  else if (type == 19)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
    });
  else if (type == 20)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
    });
  else if (type == 21)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
    });
  else if (type == 22)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
    });
  else if (type == 23)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
    });
  else if (type == 24)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
    });
  else if (type == 25)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
    });
  else if (type == 26)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
    });
  else if (type == 27)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
    });
  else if (type == 28)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
    });
  else if (type == 29)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
    });
  else if (type == 30)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
    });
  else if (type == 31)
    sort(all(a), [&](U l, U r) {
      return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
    });
  else if (type == 32)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
    });
  else if (type == 33)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
    });
  else if (type == 34)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
    });
  else if (type == 35)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
    });
  else if (type == 36)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
    });
  else if (type == 37)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
    });
  else if (type == 38)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
    });
  else if (type == 39)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
    });
  else if (type == 40)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
    });
  else if (type == 41)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
    });
  else if (type == 42)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
    });
  else if (type == 43)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
    });
  else if (type == 44)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
    });
  else if (type == 45)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
    });
  else if (type == 46)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
    });
  else if (type == 47)
    sort(all(a), [&](U l, U r) {
      return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
    });
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
  typedef F2<A, B, C, D> U;
  if (type == 0)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
    });
  else if (type == 1)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
    });
  else if (type == 2)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
    });
  else if (type == 3)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
    });
  else if (type == 4)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
    });
  else if (type == 5)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
    });
  else if (type == 6)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
    });
  else if (type == 7)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
    });
  else if (type == 8)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
    });
  else if (type == 9)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
    });
  else if (type == 10)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
    });
  else if (type == 11)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
    });
  else if (type == 12)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
    });
  else if (type == 13)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
    });
  else if (type == 14)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
    });
  else if (type == 15)
    sort(all(a), [&](U l, U r) {
      return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
    });
  else if (type == 16)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
    });
  else if (type == 17)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
    });
  else if (type == 18)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
    });
  else if (type == 19)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
    });
  else if (type == 20)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
    });
  else if (type == 21)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
    });
  else if (type == 22)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
    });
  else if (type == 23)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
    });
  else if (type == 24)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
    });
  else if (type == 25)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
    });
  else if (type == 26)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
    });
  else if (type == 27)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
    });
  else if (type == 28)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
    });
  else if (type == 29)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
    });
  else if (type == 30)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
    });
  else if (type == 31)
    sort(all(a), [&](U l, U r) {
      return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
    });
  else if (type == 32)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
    });
  else if (type == 33)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
    });
  else if (type == 34)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
    });
  else if (type == 35)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
    });
  else if (type == 36)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
    });
  else if (type == 37)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
    });
  else if (type == 38)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
    });
  else if (type == 39)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
    });
  else if (type == 40)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
    });
  else if (type == 41)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
    });
  else if (type == 42)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
    });
  else if (type == 43)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
    });
  else if (type == 44)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
    });
  else if (type == 45)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
    });
  else if (type == 46)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
    });
  else if (type == 47)
    sort(all(a), [&](U l, U r) {
      return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
    });
}

void sort(string &a) { sort(all(a)); }
void sort(int &a, int &b) {
  if (a > b)
    swap(a, b);
}
void sort(int &a, int &b, int &c) {
  sort(a, b);
  sort(a, c);
  sort(b, c);
}
void rsort(int &a, int &b) {
  if (a < b)
    swap(a, b);
}
void rsort(int &a, int &b, int &c) {
  rsort(a, b);
  rsort(a, c);
  rsort(b, c);
}
template <class T> void sort(vector<T> &a) { sort(all(a)); }
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
  sort(all(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class T> void rsort(vector<T> &a) { sort(all(a), greater<T>()); };
template <class U, class F> void rsort(vector<U> &a, F f) {
  sort(all(a), [&](U l, U r) { return f(l) > f(r); });
};

// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
  auto c = vtop(a, b);
  sort(c);
  rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  sort(c, f);
  rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
  auto c = vtop(a, b);
  rsort(c);
  rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  rsort(c, f);
  rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
  auto d = vtot(a, b, c);
  sort(d);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  sort(d, f);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
  auto d = vtot(a, b, c);
  rsort(d);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  rsort(d, f);
  rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  auto e = vtof(a, b, c, d);
  sort(e);
  rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
  auto e = vtof(a, b, c, d);
  rsort(e);
  rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
  auto b = a;
  vi ind = iota(0, sz(a));
  sortp(b, ind);
  return ind;
} /*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
  auto b = a;
  vi ind = iota(0, sz(a));
  sortp(b, ind, f);
  return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
  return ind;
}
template <class T> vi rsorti(vector<T> &a) {
  auto b = a;
  vi ind = iota(0, sz(a));
  rsortp(b, ind);
  return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
  return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
  return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
  vi ind = iota(0, sz(a));
  auto c = a;
  auto d = b;
  sortt(c, d, ind, f);
  return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
  return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
  auto c = vtop(a, b);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
  return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
  return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
  return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
  vi ind = iota(0, sz(a));
  auto d = vtof(a, b, c, ind);
  sort(d, f);
  rep(i, sz(a)) ind[i] = d[i].d;
  return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) {
    if (a[x] == a[y]) {
      if (b[x] == b[y])
        return c[x] < c[y];
      else
        return b[x] < b[y];
    } else {
      return a[x] < a[y];
    }
  });
  return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
  auto d = vtot(a, b, c);
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
  return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
  vi ind = iota(0, sz(a));
  sort(all(ind), [&](ll x, ll y) {
    if (a[x] == a[y]) {
      if (b[x] == b[y])
        return c[x] > c[y];
      else
        return b[x] > b[y];
    } else {
      return a[x] > a[y];
    }
  });
  return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
  for (ll i = 0, n = a.size(); i < n; ++i)
    sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
  for (ll i = 0, n = a.size(); i < n; ++i)
    rsort(a[i]);
}

template <class... T, class U> auto sorted(U head, T... a) {
  sort(head, a...);
  return head;
}

template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
  rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
  rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
      a[i][j][k][l][m][n] = v;
}
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
  for (auto &&vx : vecc)
    fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, ll len, const T v) {
  rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, int sh, int th, int sw, int tw, T v) {
  rep(h, sh, th) rep(w, sw, tw) xx[h][w] = v;
}
template <class T, class U> void fill(vector<T> &a, vi &ind, U val) {
  fora(v, ind) a[v] = val;
}
template <class W, class T> void fill(mvec<W> &xx, const T v) {
  fora(x, xx) fill(x, v);
}

template <typename A, size_t N> A sum(A (&a)[N]) {
  A res = 0;
  rep(i, N) res += a[i];
  return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
  A res = 0;
  rep(i, N) rep(j, O) res += a[i][j];
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
  A res = 0;
  rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
      a[i][j][k][l][m][n];
  return res;
}
//@汎用便利関数 入力
ll in() {
  ll ret;
  cin >> ret;
  return ret;
}
string sin() {
  string ret;
  cin >> ret;
  return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
  cin >> head;
  in(tail...);
}

#define din1(a)                                                                \
  ll a;                                                                        \
  cin >> a
#define din2(a, b)                                                             \
  ll a, b;                                                                     \
  cin >> a >> b
#define din3(a, b, c)                                                          \
  ll a, b, c;                                                                  \
  cin >> a >> b >> c
#define din4(a, b, c, d)                                                       \
  ll a, b, c, d;                                                               \
  cin >> a >> b >> c >> d
#define din5(a, b, c, d, e)                                                    \
  ll a, b, c, d, e;                                                            \
  cin >> a >> b >> c >> d >> e
#define din6(a, b, c, d, e, f)                                                 \
  ll a, b, c, d, e, f;                                                         \
  cin >> a >> b >> c >> d >> e >> f
#define din(...)                                                               \
  over6(__VA_ARGS__, din6, din5, din4, din3, din2, din1)(__VA_ARGS__)

#define dins1(a)                                                               \
  str a;                                                                       \
  cin >> a
#define dins2(a, b)                                                            \
  str a, b;                                                                    \
  cin >> a >> b
#define dins3(a, b, c)                                                         \
  str a, b, c;                                                                 \
  cin >> a >> b >> c
#define dins4(a, b, c, d)                                                      \
  str a, b, c, d;                                                              \
  cin >> a >> b >> c >> d
#define dins5(a, b, c, d, e)                                                   \
  str a, b, c, d, e;                                                           \
  cin >> a >> b >> c >> d >> e
#define dins6(a, b, c, d, e, f)                                                \
  str a, b, c, d, e, f;                                                        \
  cin >> a >> b >> c >> d >> e >> f
#define dins(...)                                                              \
  over6(__VA_ARGS__, dins6, dins5, dins4, dins3, dins2, dins1)(__VA_ARGS__)

#define din1d(a)                                                               \
  din1(a);                                                                     \
  a--
#define din2d(a, b)                                                            \
  din2(a, b);                                                                  \
  a--, b--
#define din3d(a, b, c)                                                         \
  din3(a, b, c);                                                               \
  a--, b--, c--
#define din4d(a, b, c, d)                                                      \
  din4(a, b, c, d);                                                            \
  a--, b--, c--, d--
#define dind(...) over4(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)

template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
  cout << head << " ";
  out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
  cout << head << " ";
  out2(tail...);
  cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }

#ifdef _DEBUG
template <class T> void err2(T &&head) { cerr << head; }
template <class T, class... U> void err2(T &&head, U &&...tail) {
  cerr << head << " ";
  err2(tail...);
}
template <class T, class... U> void err(T &&head, U &&...tail) {
  cerr << head << " ";
  err2(tail...);
  cerr << "" << endl;
}
template <class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
/*@formatter:on*/
template <class T> string out_m2(vector<T> &a, ll W = inf) {
  stringstream ss;
  if (W == inf)
    W = min(sz(a), 12ll);
  if (sz(a) == 0)
    return ss.str();
  rep(i, W) {
    ss << a[i];
    if (typeid(a[i]) == typeid(P)) {
      ss << endl;
    } else {
      ss << " ";
    }
  }
  return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m2(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
  H = min({H, sz(a), 12ll});
  W = min({W, sz(a[0]), 12ll});
  stringstream ss;
  ss << endl;
  if (key == -1)
    ss << " *|";
  else
    ss << " " << key << "|";
  rep(w, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 4 + 3) ss << "_";
  ss << "" << endl;
  rep(h, H) {
    ss << std::right << std::setw(2) << h << "|";
    rep(w, min(sz(a[h]), 12ll)) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  return ss.str();
}
template <class T>
string out_m2(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf,
              ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 12;
  H = min(H, sz(a));
  rep(i, H) {
    ss << endl;
    ss << out_m2(a[i], W, U, i);
  }
  return ss.str();
}
template <class T, size_t N> string out_m2(T (&a)[N]) {
  vector<T> b;
  resize(b, N);
  rep(i, N) { b[i] = a[i]; }
  return out_m2(b);
}
template <class T, size_t N, size_t M> string out_m2(T (&a)[N][M]) {
  vector<vector<T>> b;
  resize(b, N, M);
  rep(i, N) {
    rep(j, M) { b[i][j] = a[i][j]; }
  }
  return out_m2(b);
}
template <class T, size_t N, size_t M, size_t O>
string out_m2(T (&a)[N][M][O]) {
  vector<vector<vector<T>>> b;
  resize(b, N, M, O);
  rep(i, N) {
    rep(j, M) {
      rep(k, O) { b[i][j][k] = a[i][j][k]; }
    }
  }
  return out_m2(b);
}
string out_m2(int a) {
  stringstream ss;
  ss << a;
  return ss.str();
}
/*@formatter:on*/
template <class T>
string out_m2(mvec<mvec<T>> &a, ll H = inf, ll W = inf, int key = inf) {
  H = min({H, sz(a), 6ll});
  W = min({W, sz(a[0]), 6ll});
  stringstream ss;
  ss << endl;
  //    if (key == inf)ss << " *|"; else ss << " " << key << "|";
  if (key == inf)
    ss << " *|";
  else {
    ss << std::right << std::setw(2) << key;
    ss << "|";
  }
  rep(w, -W, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 8 + 3) ss << "_";
  ss << "" << endl;
  rep(h, -H, H) {
    ss << std::right << std::setw(2) << h << "|";
    int NW = min(sz(a[h]), 6ll);
    rep(w, -NW, NW) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  return ss.str();
} /*@formatter:on*/
template <class T>
string out_m2(mvec<mvec<mvec<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 6;
  H = min(H, sz(a));
  rep(i, -H, H) {
    ss << endl;
    ss << out_m2(a[i], W, U, i);
  }
  return ss.str();
}

/*@formatter:off*/
template <class T> string out_m2(T &a) {
  stringstream ss;
  ss << a;
  return ss.str();
}
/*@formatter:on*/
template <class T> string out_m(vector<T> &a, ll W = inf) {
  stringstream ss;
  if (W == inf)
    W = min(sz(a), 12ll);
  if (sz(a) == 0)
    return ss.str();
  rep(i, W) { ss << a[i] << " "; }
  ss << "" << endl;
  return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
  H = min({H, sz(a), 12ll});
  W = min({W, sz(a[0]), 12ll});
  stringstream ss;
  ss << endl;
  if (key == -1)
    ss << " *|";
  else
    ss << " " << key << "|";
  rep(w, W) ss << std::right << std::setw(4) << w;
  ss << "" << endl;
  rep(w, W * 4 + 3) ss << "_";
  ss << "" << endl;
  rep(h, H) {
    ss << std::right << std::setw(2) << h << "|";
    rep(w, min(sz(a[h]), 12ll)) {
      if (abs(a[h][w]) == linf)
        ss << "   e"
           << "";
      else
        ss << std::right << std::setw(4) << a[h][w];
    }
    ss << "" << endl;
  }
  ss << endl;
  return ss.str();
}
template <class T>
string out_m(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
  stringstream ss;
  if (H == inf)
    H = 5;
  H = min(H, sz(a));
  rep(i, H) {
    ss << endl;
    ss << out_m(a[i], W, U, i);
  }
  ss << endl;
  return ss.str();
}
string out_m(int a) {
  stringstream ss;
  ss << a << endl;
  return ss.str();
}
template <class T> string out_m(T &a) {
  stringstream ss;
  ss << a << endl;
  return ss.str();
}
template <class T> void outv(vector<T> &a, ll W = inf) {
  cout << out_m(a, W) << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
  cout << out_m(a, H, W, key) << endl;
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
  cout << out_m(a, H, W, U) << endl;
}
#else
template <class T> void outv(vector<T> &a, ll W = inf) {
  rep(i, min(W, sz(a))) { cout << a[i] << " "; }
  cout << "" << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
  rep(i, min(H, sz(a))) { outv(a[i], W); }
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
  ;
}
#define err(...) ;
#endif
template <class T> void outl(vector<T> &a, int n = inf) {
  rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
  rep(i, sz(a)) {
    rep(j, sz(a[i])) { cout << a[i][j]; }
    cout << endl;
  }
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
template <class T> void na(vector<T> &a, ll n) {
  a.resize(n);
  rep(i, n) cin >> a[i];
}
template <class T> void na(set<T> &a, ll n) { rep(i, n) a.insert(in()); }
#define dna(a, n)                                                              \
  vi a(n);                                                                     \
  rep(dnai, n) cin >> a[dnai];
#define dnad(a, n)                                                             \
  vi a(n);                                                                     \
  rep(dnai, n) cin >> a[dnai], a[dnai]--;
template <class T> void nao(vector<T> &a, ll n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
  a.resize(n);
  rep(i, n) cin >> a[i], a[i]--;
}
template <class T> void nad(set<T> &a, ll n) { rep(i, n) a.insert(in() - 1); }
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i];
}
template <class T, class U> void na2(set<T> &a, set<U> &b, ll n) {
  rep(i, n) {
    a.insert(in());
    b.insert(in());
  }
}

#define dna2(a, b, n)                                                          \
  vi a(n), b(n);                                                               \
  rep(dna2i, n) cin >> a[dna2i] >> b[dna2i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n + 1);
  b.resize(n + 1);
  a[0] = b[0] = 0;
  rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
#define dna2d(a, b, n)                                                         \
  vi a(n), b(n);                                                               \
  rep(dna2di, n) {                                                             \
    cin >> a[dna2di] >> b[dna2di];                                             \
    a[dna2di]--, b[dna2di]--;                                                  \
  }
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n)                                                       \
  vi a(n), b(n), c(n);                                                         \
  rep(dna3i, n) cin >> a[dna3i] >> b[dna3i] >> c[dna3i];
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n)                                                      \
  vi a(n), b(n), c(n);                                                         \
  rep(dna3di, n) {                                                             \
    cin >> a[dna3di] >> b[dna3di] >> c[dna3di];                                \
    a[dna3di]--, b[dna3di]--, c[dna3di]--;                                     \
  }
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
  a.resize(n);
  b.resize(n);
  c.resize(n);
  d.resize(n);
  rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n)                                                    \
  vi a(n), b(n), c(n), d(n);                                                   \
  rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i];
#define dna4d(a, b, c, d, n)                                                   \
  vi a(n), b(n), c(n), d(n);                                                   \
  rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i],           \
      --a[dna4i], --b[dna4i], --c[dna4i], --d[dna4i];
#define nt(a, h, w)                                                            \
  resize(a, h, w);                                                             \
  rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w)                                                           \
  resize(a, h, w);                                                             \
  rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w)                                                           \
  resize(a, h + 2, w + 2);                                                     \
  fill(a, '#');                                                                \
  rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
// デバッグ
#define sp << " " <<

#define deb1(x) debugName(x) << " = " << out_m2(x)
#define deb_2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) << ", " << deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) << ", " << deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb_4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
#define deb7(x, ...) deb1(x) << ", " << deb6(__VA_ARGS__)
#define deb8(x, ...) deb1(x) << ", " << deb7(__VA_ARGS__)
#define deb9(x, ...) deb1(x) << ", " << deb8(__VA_ARGS__)
#define deb10(x, ...) deb1(x) << ", " << deb9(__VA_ARGS__)

#ifdef _DEBUG
#define deb(...)                                                               \
  cerr << over10(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb_4,      \
                 deb_3, deb_2, deb1)(__VA_ARGS__)                              \
       << endl

#define base_keta 8
void print_n_base(int x, int base) { cerr << bitset<base_keta>(x) << endl; }
template <class T> void print_n_base(vector<T> X, int base) {
  cerr << endl;
  for (auto &&x : X) {
    print_n_base(x, base);
  }
  cerr << endl;
}

// n進数
#define deb2(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 2);
#define deb3(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 3);
#define deb4(x)                                                                \
  cerr << debugName(x) << " = ";                                               \
  print_n_base(x, 4);

#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#endif

#define debugline(x)                                                           \
  cerr << x << " "                                                             \
       << "(L:" << __LINE__ << ")" << '\n'

//@formatter:off
// よく使うクラス、構造体
// graphでredefineしているため、書き換えたら向こうも書き換える
struct unionfind {
  vector<ll> par;
  vector<ll> siz;
  vector<ll> es;
  ll n, trees; // 連結グループの数(親の種類)
  unionfind(ll n) : n(n), trees(n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
  }
  ll root(ll x) {
    if (par[x] == x) {
      return x;
    } else {
      return par[x] = root(par[x]);
    }
  }
  ll operator()(ll x) { return root(x); }
  bool unite(ll x, ll y) {
    x = root(x);
    y = root(y);
    es[x]++;
    if (x == y)
      return false;
    if (siz[x] > siz[y])
      swap(x, y);
    trees--;
    par[x] = y;
    siz[y] += siz[x];
    es[y] += es[x];
    return true;
  }
  bool same(ll x, ll y) { return root(x) == root(y); }
  ll size(ll x) { return siz[root(x)]; }
  ll esize(ll x) { return es[root(x)]; }
  vi sizes() {
    vi cou(n);
    vi ret;
    ret.reserve(n);
    rep(i, n) { cou[root(i)]++; }
    rep(i, n) {
      if (cou[i])
        ret.push_back(cou[i]);
    }
    return ret;
  }
  // つながりを無向グラフと見なし、xが閉路に含まれるか判定
  bool close(ll x) { return esize(x) >= size(x); }
  vector<vi> sets() {
    vi ind(n, -1);
    ll i = 0;
    vvi(res, trees);
    rep(j, n) {
      ll r = root(j);
      if (ind[r] == -1)
        ind[r] = i++;
      res[ind[r]].push_back(j);
    }
    rep(i, trees) {
      ll r = root(res[i][0]);
      if (res[i][0] == r)
        continue;
      rep(j, 1, sz(res[i])) {
        if (res[i][j] == r) {
          swap(res[i][0], res[i][j]);
          break;
        }
      }
    }
    return res;
  }
}; //@formatter:off

using bll = __int128;
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;

std::ostream &operator<<(std::ostream &dest, __int128_t value) {
  std::ostream::sentry s(dest);
  if (s) {
    __uint128_t tmp = value < 0 ? -value : value;
    char buffer[128];
    char *d = std::end(buffer);
    do {
      --d;
      *d = "0123456789"[tmp % 10];
      tmp /= 10;
    } while (tmp != 0);
    if (value < 0) {
      --d;
      *d = '-';
    }
    ll len = std::end(buffer) - d;
    if (dest.rdbuf()->sputn(d, len) != len) {
      dest.setstate(std::ios_base::badbit);
    }
  }
  return dest;
}
//__int128 toi128(string &s) {    __int128 ret = 0;    for (ll i = 0; i <
//s.length(); ++i)        if ('0' <= s[i] && s[i] <= '9')            ret = 10 *
//ret + s[i] - '0';    return ret;}

// エラー
void ole() {
#ifdef _DEBUG
  debugline("ole");
  exit(0);
#endif
  string a = "a";
  rep(i, 30) a += a;
  rep(i, 1 << 17) cout << a << endl;
  cout << "OLE 出力長制限超過" << endl;
  exit(0);
}
void re() {
  assert(0 == 1);
  exit(0);
}
void tle() {
  while (inf)
    cout << inf << endl;
}

// 便利関数

// テスト用
#define rand xor128_
unsigned long xor128_(void) {
  static unsigned long x = 123456789, y = 362436069, z = 521288629,
                       w = 88675123;
  unsigned long t;
  t = (x ^ (x << 11));
  x = y;
  y = z;
  z = w;
  return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
  assert(min <= max);
  if (min >= 0 && max >= 0) {
    return rand() % (max + 1 - min) + min;
  } else if (max < 0) {
    return -rand(-max, -min);
  } else {
    if (rand() % 2) {
      return rand(0, max);
    } else {
      return -rand(0, -min);
    }
  }
}
ll rand(ll max) { return rand(0, max); }
vi ranv(ll n, ll min, ll max) {
  vi v(n);
  rep(i, n) v[i] = rand(min, max);
  return v;
}
str ransu(ll n) {
  str s;
  rep(i, n) s += (char)rand('A', 'Z');
  return s;
}
str ransl(ll n) {
  str s;
  rep(i, n) s += (char)rand('a', 'z');
  return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
  vi v(n);
  bool bad = 1;
  while (bad) {
    bad = 0;
    v.resize(n);
    rep(i, n) {
      if (i && min > max - v[i - 1]) {
        bad = 1;
        break;
      }
      if (i)
        v[i] = v[i - 1] + rand(min, max - v[i - 1]);
      else
        v[i] = rand(min, max);
    }
  }
  return v;
}
// 便利 汎用

void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
  l.resize(n);
  r.resize(n);
  rep(i, n) {
    l[i] = rand(min, max);
    r[i] = l[i] + rand(0, max - l[i]);
  }
}
template <class T> vector<pair<T, int>> run_length(vector<T> &a) {
  vector<pair<T, int>> ret;
  ret.eb(a[0], 1);
  rep(i, 1, sz(a)) {
    if (ret.back().fi == a[i]) {
      ret.back().se++;
    } else {
      ret.eb(a[i], 1);
    }
  }
  return ret;
}
vector<pair<char, ll>> run_length(string &a) {
  vector<pair<char, ll>> ret;
  ret.eb(a[0], 1);
  rep(i, 1, sz(a)) {
    if (ret.back().fi == a[i]) {
      ret.back().se++;
    } else {
      ret.eb(a[i], 1);
    }
  }
  return ret;
}
template <class F> ll mgr(ll ok, ll ng, F f) {
  bool han = true;
  if (ok < ng)
    while (ng - ok > 1) {
      ll mid = (ok + ng) >> 1;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  else
    while (ok - ng > 1) {
      ll mid = (ok + ng) >> 1;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  return ok;
}
template <class F> dou mgrd(dou ok, dou ng, F f, int kai = 100) {
  bool han = true;
  if (ok < ng)
    rep(i, kai) {
      dou mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  else
    rep(i, kai) {
      dou mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid, han = true;
      else
        ng = mid, han = false;
      deb(mid, han);
    }
  return ok;
}
// strを整数として比較
string smax(str &a, str b) {
  if (sz(a) < sz(b)) {
    return b;
  } else if (sz(a) > sz(b)) {
    return a;
  } else if (a < b)
    return b;
  else
    return a;
}
// strを整数として比較
string smin(str &a, str b) {
  if (sz(a) > sz(b)) {
    return b;
  } else if (sz(a) < sz(b)) {
    return a;
  } else if (a > b)
    return b;
  else
    return a;
}
// エラー-1
template <typename W, typename T> ll find(vector<W> &a, int l, const T key) {
  rep(i, l, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
  rep(i, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
  rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
  return mp(-1, -1);
}
template <typename W, typename U>
T find(vector<vector<vector<W>>> &a, const U key) {
  rep(i, sz(a)) rep(j, sz(a[0]))
      rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
  return mt(-1, -1, -1);
}
// stringも書く
int find(string &s, const string key) {
  int klen = sz(key);
  rep(i, sz(s) - klen + 1) {
    if (s[i] != key[0])
      continue;
    if (s.substr(i, klen) == key) {
      return i;
    }
  }
  return -1;
}
int find(string &s, int l, const string key) {
  int klen = sz(key);
  rep(i, l, sz(s) - klen + 1) {
    if (s[i] != key[0])
      continue;
    if (s.substr(i, klen) == key) {
      return i;
    }
  }
  return -1;
}
int find(string &s, const char key) {
  rep(i, sz(s)) {
    if (s[i] == key)
      return i;
  }
  return -1;
}
int find(string &s, int l, const char key) {
  rep(i, l, sz(s)) {
    if (s[i] == key)
      return i;
  }
  return -1;
}
template <typename W, typename T> ll count2(W &a, const T k) { return a == k; }
template <typename W, typename T> ll count2(vector<W> &a, const T k) {
  ll ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
template <typename W, typename T> ll count(vector<W> &a, const T k) {
  ll ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
vi count(vi &a) {
  int ma = 0;
  fora(v, a) {
    if (ma < v)
      ma = v;
  }
  vi res(ma + 1);
  fora(v, a) { res[v]++; }
  return res;
}
ll count(str &a, str k) {
  ll ret = 0, len = k.length();
  auto pos = a.find(k);
  while (pos != string::npos)
    pos = a.find(k, pos + len), ++ret;
  return ret;
}
vi count(str &a) {
  vi cou(26);
  char c = 'a';
  if ('A' <= a[0] && a[0] <= 'Z')
    c = 'A';
  rep(i, sz(a))++ cou[a[i] - c];
  return cou;
}
#define couif count_if
// algorythm

ll rev(ll a) {
  ll res = 0;
  while (a) {
    res *= 10;
    res += a % 10;
    a /= 10;
  }
  return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class U> void rev(vector<vector<U>> &a) {
  vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
  rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
  a = b;
}
void rev(string &a) { reverse(all(a)); }
constexpr ll p10[] = {1,
                      10,
                      100,
                      1000,
                      10000,
                      100000,
                      1000000,
                      10000000,
                      100000000,
                      1000000000,
                      10000000000ll,
                      100000000000ll,
                      1000000000000ll,
                      10000000000000ll,
                      100000000000000ll,
                      1000000000000000ll,
                      10000000000000000ll,
                      100000000000000000ll,
                      1000000000000000000ll};

// 0は0桁
ll keta(ll v) {
  if (v < p10[9]) {
    if (v < p10[4]) {
      if (v < p10[2]) {
        if (v < p10[1]) {
          if (v < p10[0])
            return 0;
          else
            return 1;
        } else
          return 2;
      } else {
        if (v < p10[3])
          return 3;
        else
          return 4;
      }
    } else {
      if (v < p10[7]) {
        if (v < p10[5])
          return 5;
        else if (v < p10[6])
          return 6;
        else
          return 7;
      } else {
        if (v < p10[8])
          return 8;
        else
          return 9;
      }
    }
  } else {
    if (v < p10[13]) {
      if (v < p10[11]) {
        if (v < p10[10])
          return 10;
        else
          return 11;
      } else {
        if (v < p10[12])
          return 12;
        else
          return 13;
      }
    } else {
      if (v < p10[15]) {
        if (v < p10[14])
          return 14;
        else
          return 15;
      } else {
        if (v < p10[17]) {
          if (v < p10[16])
            return 16;
          else
            return 17;
        } else {
          if (v < p10[18])
            return 18;
          else
            return 19;
        }
      }
    }
  }
}
ll getr(ll a, ll keta) { return (a / (ll)pow(10, keta)) % 10; }
// 上から何桁目か
ll getl(ll a, ll ket) {
  int sketa = keta(a);
  return getr(a, sketa - 1 - ket);
}
ll dsum(ll v, ll sin = 10) {
  ll ret = 0;
  for (; v; v /= sin)
    ret += v % sin;
  return ret;
}

ll mask10(ll v) { return p10[v] - 1; }
// 変換系
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
template <class T> auto keys(T &a) {
  vector<decltype((a.begin())->fi)> res;
  for (auto &&k : a)
    res.push_back(k.fi);
  return res;
}
template <class T> auto values(T &a) {
  vector<decltype((a.begin())->se)> res;
  for (auto &&k : a)
    res.push_back(k.se);
  return res;
}
template <class T, class U> bool chma(T &a, const U &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <class T> constexpr T min(T a, signed b) { return a < b ? a : b; }
template <class T> constexpr T max(T a, signed b) { return a < b ? b : a; }
template <class T> constexpr T min(T a, T b, T c) {
  return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> constexpr T max(T a, T b, T c) {
  return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> T min(vector<T> &a) { return *min_element(all(a)); }
template <class T> T mini(vector<T> &a) {
  return min_element(all(a)) - a.begin();
}
template <class T> T min(vector<T> &a, ll n) {
  return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T min(vector<T> &a, ll s, ll n) {
  return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a) { return *max_element(all(a)); }
template <class T, class U> T max(vector<T> &a, vector<U> &b) {
  return max(*max_element(all(a)), *max_element(all(b)));
}
template <class T> T maxi(vector<T> &a) {
  return max_element(all(a)) - a.begin();
}
template <class T> T max(vector<T> &a, ll n) {
  return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a, ll s, ll n) {
  return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> A max(A (&a)[N]) {
  A res = a[0];
  rep(i, N) res = max(res, a[i]);
  return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
  A res = max(a[0]);
  rep(i, N) res = max(res, max(a[i]));
  return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
  A res = a[0];
  rep(i, N) res = min(res, a[i]);
  return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
          size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, min(a[i]));
  return res;
}
template <class T> T sum(vector<T> &v, ll s, ll t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += v[i];
  return ret;
}
template <class T> T sum(vector<T> &v, ll t = inf) { return sum(v, 0, t); }
template <class T> T sum(vector<vector<T>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<T>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T> T sum(vector<vector<vector<T>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v, int t = inf) {
  return sum(v, 0, t);
}
template <class T>
T sum(vector<vector<vector<vector<vector<T>>>>> &v, int s, int t) {
  T ret = 0;
  rep(i, s, min(sz(v), t)) ret += sum(v[i]);
  return ret;
}
template <class T>
T sum(vector<vector<vector<vector<vector<T>>>>> &v, int t = inf) {
  return sum(v, 0, t);
}

template <class T> auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
  auto q = r;
  T ret = 0;
  while (sz(q)) {
    ret += q.top();
    q.pop();
  }
  return ret;
}
template <class T> auto sum(priority_queue<T> &r) {
  auto q = r;
  T ret = 0;
  while (sz(q)) {
    ret += q.top();
    q.pop();
  }
  return ret;
}
// template<class T, class U, class... W>  auto sumn(vector<T> &v, U head, W...
// tail) {    auto ret = sum(v[0], tail...);    rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...);    return ret;}
vi v_i(vi &a) {
  int n = max(a) + 1;
  vi ret(n, -1);
  rep(i, sz(a)) { ret[a[i]] = i; }
  return ret;
}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
template <class T> void clear(queue<T> &q) {
  while (q.size())
    q.pop();
}
template <class T> T *negarr(ll size) {
  T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
  return body + size;
}
template <class T> T *negarr2(ll h, ll w) {
  double **dummy1 = new double *[2 * h + 1];
  double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
  dummy1[0] = dummy2 + w;
  for (ll i = 1; i <= 2 * h + 1; ++i) {
    dummy1[i] = dummy1[i - 1] + 2 * w + 1;
  }
  double **a = dummy1 + h;
  return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
  return ret;
}
// kと同じものの数
template <class T, class U> vi imo(vector<T> &a, U k) {
  vector<T> ret = a;
  rep(i, sz(ret)) ret[i] = a[i] == k;
  rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
  return ret;
}
template <class T> vector<T> imox(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
  return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
  return ret;
}
template <class T> vector<T> ima(vector<T> &v) {
  vector<T> ret = v;
  rep(i, sz(ret) - 1) chma(ret[i + 1], ret[i]);
  return ret;
}
// template<class T> vector<T> rimi(vector<T> &v) {    vector<T> ret = v; rer(i,
// sz(ret) - 1, 1)chmi(ret[i - 1], ret[i]);    return ret;} template<class T>
// vector<T> rima(vector<T> &v) {    vector<T> ret = v;    rer(i, sz(ret) - 1,
// 1)chma(ret[i - 1], ret[i]);    return ret;}
template <class T> struct ruiC {
  vector<T> rui;
  ruiC(vector<T> &ru) : rui(ru) {}
  /*先頭0*/
  ruiC() : rui(1, 0) {}
  T operator()(ll l, ll r) {
    if (l > r) {
      cerr << "ruic ";
      deb(l, r);
      assert(0);
    }
    return rui[r] - rui[l];
  }
  T operator()(int r) { return operator()(0, r); }
  /*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
  /*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
  //    T operator[](ll i) { return rui[i + 1] - rui[i]; }
  T operator[](ll i) { return rui[i]; }
  /*0から順に追加される必要がある*/
  void operator+=(T v) { rui.push_back(rui.back() + v); }
  void add(int i, T v) {
    if (sz(rui) - 1 != i)
      ole();
    operator+=(v);
  }
  T back() { return rui.back(); }
  ll size() { return rui.size(); }
  auto begin() { return rui.begin(); }
  auto end() { return rui.end(); }
};
template <class T> struct ruimax {
  template <typename Monoid> struct SegmentTree { /*pairで処理*/
    int sz;
    vector<Monoid> seg;
    const Monoid M1 = mp(MIN(T), -1);
    Monoid f(Monoid a, Monoid b) { return max(a, b); }
    void build(vector<T> &a) {
      int n = sz(a);
      sz = 1;
      while (sz < n)
        sz <<= 1;
      seg.assign(2 * sz, M1);
      rep(i, n) { seg[i + sz] = mp(a[i], i); }
      for (int k = sz - 1; k > 0; k--) {
        seg[k] = f(seg[k << 1], seg[(k << 1) | 1]);
      }
    }
    Monoid query(int a, int b) {
      Monoid L = M1, R = M1;
      for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
        if (a & 1)
          L = f(L, seg[a++]);
        if (b & 1)
          R = f(seg[--b], R);
      }
      return f(L, R);
    }
    Monoid operator[](const int &k) const { return seg[k + sz]; }
  };

private:
  vector<T> ve;
  SegmentTree<pair<T, int>> seg;
  vector<T> rv;
  vector<T> ri;
  bool build = false;

public:
  int n;
  ruimax(vector<T> &a) : ve(a), n(sz(a)) {
    int index = -1;
    int ma = MIN(T);
    rv.resize(n + 1);
    ri.resize(n + 1);
    rv[0] = -linf;
    ri[0] = -1;
    rep(i, n) {
      if (chma(ma, a[i])) {
        index = i;
      }
      rv[i + 1] = ma;
      ri[i + 1] = index;
    }
  }
  T operator()(int l, int r) {
    if (!(l <= r && 0 <= l && r <= n)) {
      deb(l, r, n);
      assert(0);
    }
    if (l == 0) {
      return rv[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).first;
    }
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  T getv(int l, int r) { return operator()(l, r); }
  T geti(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return ri[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).second;
    }
  }
  T geti(int r = inf) { return geti(0, min(r, n)); };
  T getv(int r = inf) { return getv(0, min(r, n)); };
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};
template <class T> struct ruimin {
  template <typename Monoid> struct SegmentTree { /*pairで処理*/
    int sz;
    vector<Monoid> seg;
    const Monoid M1 = mp(MAX(T), -1);
    Monoid f(Monoid a, Monoid b) { return min(a, b); }
    void build(vector<T> &a) {
      int n = sz(a);
      sz = 1;
      while (sz < n)
        sz <<= 1;
      seg.assign(2 * sz, M1);
      rep(i, n) { seg[i + sz] = mp(a[i], i); }
      for (int k = sz - 1; k > 0; k--) {
        seg[k] = f(seg[k << 1], seg[(k << 1) | 1]);
      }
    }
    Monoid query(int a, int b) {
      Monoid L = M1, R = M1;
      for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
        if (a & 1)
          L = f(L, seg[a++]);
        if (b & 1)
          R = f(seg[--b], R);
      }
      return f(L, R);
    }
    Monoid operator[](const int &k) const { return seg[k + sz]; }
  };

private:
  vector<T> ve;
  SegmentTree<pair<T, int>> seg;
  vector<T> rv;
  vector<T> ri;
  bool build = false;
  int n;

public:
  ruimin(vector<T> &a) : ve(a), n(sz(a)) {
    int index = -1;
    int mi = MAX(T);
    rv.resize(n + 1);
    ri.resize(n + 1);
    rv[0] = linf;
    ri[0] = -1;
    rep(i, n) {
      if (chmi(mi, a[i])) {
        index = i;
      }
      rv[i + 1] = mi;
      ri[i + 1] = index;
    }
  }
  T operator()(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return rv[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).first;
    }
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  T getv(int l, int r) { return operator()(l, r); }
  T geti(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    if (l == 0) {
      return ri[r];
    } else {
      if (!build)
        seg.build(ve), build = true;
      return seg.query(l, r).second;
    }
  }
  T geti(int r = inf) { return geti(0, min(r, n)); };
  T getv(int r = inf) { return getv(0, min(r, n)); };
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};

template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
  fora(v, a.rui) os << v << " ";
  return os;
}
template <class T> vector<T> ruiv(vector<T> &a) {
  vector<T> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
  return ret;
}
template <class T> ruiC<T> ruic() { return ruiC<T>(); }
template <class T> ruiC<T> ruic(vector<T> &a) {
  vector<T> ret = ruiv(a);
  return ruiC<T>(ret);
}
vvi() ruib(vi &a) {
  vvi(res, 61, sz(a) + 1);
  rep(k, 61) {
    rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }
  }
  return res;
}
vector<ruiC<int>> ruibc(vi &a) {
  vector<ruiC<int>> ret(61);
  vvi(res, 61, sz(a));
  rep(k, 61) {
    rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; }
    ret[k] = ruic(res[k]);
  }
  return ret;
}
vector<ll> ruiv(string &a) {
  if (sz(a) == 0)
    return vi(1);
  ll dec = ('0' <= a[0] && a[0] <= '9') ? '0' : 0;
  vector<ll> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + a[i] - dec;
  return ret;
}
ruiC<ll> ruic(string &a) {
  vector<ll> ret = ruiv(a);
  return ruiC<ll>(ret);
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
  vi ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
  return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
  vi ret = ruiv(a, k);
  return ruiC<ll>(ret);
}

// h query
template <class T> vector<T> imoh(vector<vector<T>> &v, int w) {
  vector<T> ret(sz(v));
  rep(h, sz(ret)) { ret[h] = v[h][w]; }
  rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; }
  return ret;
}
template <class T> vector<T> ruih(vector<vector<T>> &v, int w) {
  vector<T> ret(sz(v) + 1);
  rep(h, sz(v)) { ret[h + 1] = v[h][w]; }
  rep(i, sz(v)) { ret[i + 1] += ret[i]; }
  return ret;
}
template <class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) {
  vector<T> ret = ruih(a, w);
  return ruiC<T>(ret);
}

// xor
template <class T> struct ruixC {
  vector<T> rui;
  ruixC(vector<T> &ru) : rui(ru) {}
  T operator()(ll l, ll r) {
    if (l > r) {
      cerr << "ruiXc ";
      deb(l, r);
      assert(0);
    }
    return rui[r] ^ rui[l];
  }
  T operator[](ll i) { return rui[i]; }
  T back() { return rui.back(); }
  ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
  vector<T> ret(a.size() + 1);
  rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
  return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
  vi ret = ruix(a);
  return ruixC<ll>(ret);
}
template <class T> vector<T> ruim(vector<T> &a) {
  vector<T> res(a.size() + 1, 1);
  rep(i, a.size()) res[i + 1] = res[i] * a[i];
  return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
  ll n = sz(a);
  vector<T> ret(n + 1);
  rep(i, 1, n) {
    ret[i] = a[i - 1];
    chmi(ret[i + 1], ret[i]);
  }
  return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> struct rruiC {
  vector<T> rui;
  int n;
  rruiC(vector<T> &a) : n(sz(a)) {
    rui.resize(n + 1);
    rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; }
  }
  /*[r l)*/
  T operator()(int r, int l) {
    r++;
    l++;
    assert(l <= r && l >= 0 && r <= n);
    return rui[l] - rui[r];
  }
  T operator()(int l) { return operator()(n - 1, l); }
  T operator[](int i) { return operator()(i); }
};
template <class T> ostream &operator<<(ostream &os, rruiC<T> a) {
  fora(v, a.rui) os << v << " ";
  return os;
}

#define rrui rruic
template <class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }

// 掛け算
template <class T> struct ruimulC {
  vector<T> rv;
  int n;
  ruimulC(vector<T> &a) : rv(a), n(sz(a)) {
    rv.resize(n + 1);
    rv[0] = 1;
    rep(i, n) { rv[i + 1] = a[i] * rv[i]; }
  }
  ruimulC() : n(0) {
    rv.resize(n + 1);
    rv[0] = 1;
  }
  void operator+=(T v) {
    rv.push_back(rv.back() * v);
    n++;
  }
  T operator()(int l, int r) {
    assert(l <= r && 0 <= l && r <= n);
    return rv[r] / rv[l];
  }
  T operator()(int r = inf) { return operator()(0, min(r, n)); }
  T operator[](int r) { return operator()(0, r); }
  auto begin() { return rv.begin(); }
  auto end() { return rv.end(); }
};
template <class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template <class T> ruimulC<T> ruimul() {
  vector<T> a;
  return ruimulC<T>(a);
}
/*@formatter:off*/
template <class T> T *rruim(vector<T> &a) {
  ll len = a.size();
  T *body = (T *)malloc((len + 1) * sizeof(T));
  T *res = body + 1;
  res[len - 1] = 1;
  rer(i, len - 1) res[i - 1] = res[i] * a[i];
  return res;
}
template <class T, class U> void inc(pair<T, U> &a, U v = 1) {
  a.first += v, a.second += v;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
  for (auto &u : a)
    inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, W v = 1) {
  for (auto &u : a)
    dec(u, v);
  for (auto &u : b)
    dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
  for (auto &u : a)
    dec(u, 1);
  for (auto &u : b)
    dec(u, 1);
  for (auto &u : c)
    dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool ins(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
  return ins(0, i, sz(a)) && ins(0, j, sz(a));
}
#define inside ins
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(vector<T> &a) {
  vector<T> ret = a;
  fora(v, ret) v = u(v);
  return ret;
}

// 添え字を返す
template <class F> ll goldd_l(ll left, ll right, F calc) {
  double GRATIO = 1.6180339887498948482045868343656;
  ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
  ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
  ll fl = calc(lm);
  ll fr = calc(rm);
  while (right - left > 10) {
    if (fl < fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + (ll)((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  ll minScore = MAX(ll);
  ll resIndex = left;
  for (ll i = left; i < right + 1; ++i) {
    ll score = calc(i);
    if (minScore > score) {
      minScore = score;
      resIndex = i;
    }
  }
  return resIndex;
}
template <class F> ll goldt_l(ll left, ll right, F calc) {
  double GRATIO = 1.6180339887498948482045868343656;
  ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
  ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
  ll fl = calc(lm);
  ll fr = calc(rm);
  while (right - left > 10) {
    if (fl > fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + (ll)((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  if (left > right) {
    ll l = left;
    left = right;
    right = l;
  }
  ll maxScore = MIN(ll);
  ll resIndex = left;
  for (ll i = left; i < right + 1; ++i) {
    ll score = calc(i);
    if (maxScore < score) {
      maxScore = score;
      resIndex = i;
    }
  }
  return resIndex;
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> dou goldd_d(dou left, dou right, F calc, ll loop = 200) {
  dou GRATIO = 1.6180339887498948482045868343656;
  dou lm = left + ((right - left) / (GRATIO + 1.0));
  dou rm = lm + ((right - lm) / (GRATIO + 1.0));
  dou fl = calc(lm);
  dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
  ll k = 141;
  loop++;
  while (--loop) {
    if (fl < fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + ((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + ((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  return left;
}
template <class F> dou goldt_d(dou left, dou right, F calc, ll loop = 200) {
  double GRATIO = 1.6180339887498948482045868343656;
  dou lm = left + ((right - left) / (GRATIO + 1.0));
  dou rm = lm + ((right - lm) / (GRATIO + 1.0));
  dou fl = calc(lm);
  dou fr = calc(rm);
  loop++;
  while (--loop) {
    if (fl > fr) {
      right = rm;
      rm = lm;
      fr = fl;
      lm = left + ((right - left) / (GRATIO + 1.0));
      fl = calc(lm);
    } else {
      left = lm;
      lm = rm;
      fl = fr;
      rm = lm + ((right - lm) / (GRATIO + 1.0));
      fr = calc(rm);
    }
  }
  return left;
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> ll goldd_ls(ll l, ll r, F calc, ll time = 2000) {
  auto lim = milliseconds(time - 20);
  ll mini = 0, minv = MAX(ll); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
    ll nl = l;
    ll nr = l + haba;
    rep(i, k) {
      ll ni = goldd_l(nl, nr, calc);
      if (chmi(minv, calc(ni)))
        mini = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return mini;
}
template <class F> ll goldt_ls(ll l, ll r, F calc, ll time = 2000) {
  auto lim = milliseconds(time - 20);
  ll maxi = 0, maxv = MIN(ll); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
    ll nl = l;
    ll nr = l + haba;
    rep(i, k) {
      ll ni = goldt_l(nl, nr, calc);
      if (chma(maxv, calc(ni)))
        maxi = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return maxi;
}
template <class F>
dou goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
  auto lim = milliseconds(time - 20);
  dou mini = 0, minv = MAX(dou); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    dou haba = (r - l) / k;
    dou nl = l;
    dou nr = l + haba;
    rep(i, k) {
      dou ni = goldd_d(nl, nr, calc);
      if (chmi(minv, calc(ni)))
        mini = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return mini;
}
template <class F>
dou goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
  auto lim = milliseconds(time - 20);
  dou maxi = 0, maxv = MIN(dou); /*区間をk分割する*/
  rep(k, 1, inf) {
    auto s = system_clock::now();
    dou haba = (r - l) / k;
    dou nl = l;
    dou nr = l + haba;
    rep(i, k) {
      dou ni = goldt_d(nl, nr, calc);
      if (chma(maxv, calc(ni)))
        maxi = ni;
      nl = nr;
      nr = nl + haba;
    }
    auto end = system_clock::now();
    auto part = duration_cast<milliseconds>(end - s);
    auto elapsed = duration_cast<milliseconds>(end - start_time);
    if (elapsed + part * 2 >= lim) {
      break;
    }
  }
  return maxi;
}
template <class T> T min(vector<vector<T>> &a) {
  T res = MAX(T);
  rep(i, a.size()) chmi(res, *min_element(all(a[i])));
  return res;
}
template <class T> T max(vector<vector<T>> &a) {
  T res = MIN(T);
  rep(i, a.size()) chma(res, *max_element(all(a[i])));
  return res;
}
#ifdef _DEBUG
auto pow(int a, int k) {
  static bool was = 1;
  if (was) {
    message += "if integer use *powi* it's very fast\n";
  }
  was = 0;
  return std::pow(a, k);
}
auto pow(signed a, int k) { return pow((int)a, k); }
auto pow(signed a, signed k) { return pow((int)a, (int)k); }
#endif
// 整数型のpow
int powi(int a, int k) {
  if (a == 2)
    return 1ll << k;
  int res = 1;
  int x = a;
  while (k) {
    res *= (k & 1) * x;
    x *= x;
    k >>= 1;
  }
  return res;
}
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
  assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
  return (m >> keta) & 1;
}
// bget(n)次元
//                           NならN-1まで
vector<vi> bget2(vi &a, int keta_size) {
  vvi(res, keta_size, sz(a));
  rep(k, keta_size) {
    rep(i, sz(a)) { res[k][i] = bget(a[i], k); }
  }
  return res;
}
vi bget1(vi &a, int keta) {
  vi res(sz(a));
  rep(i, sz(a)) { res[i] = bget(a[i], keta); }
  return res;
}
ll bget(ll m, ll keta, ll sinsuu) {
  m /= (ll)pow(sinsuu, keta);
  return m % sinsuu;
}
constexpr ll bit(ll n) {
#ifdef _DEBUG
  assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
  return (1LL << (n));
}
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
//{0, 2} -> 101
ll bit(vi &a) {
  int m = 0;
  for (auto &&v : a)
    m |= bit(v);
  return m;
}

//{1, 1, 0} -> 011
// bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bitb(vi &a) {
  int m = 0;
  rep(i, sz(a)) if (a[i]) m |= bit(i);
  return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) { return n & -n; }
ll lbiti(ll n) { return log2(n & -n); }
// 最上位ビット
ll hbit(ll n) {
  n |= (n >> 1);
  n |= (n >> 2);
  n |= (n >> 4);
  n |= (n >> 8);
  n |= (n >> 16);
  n |= (n >> 32);
  return n - (n >> 1);
}
ll hbiti(ll n) { return log2(hbit(n)); }
ll hbitk(ll n) {
  ll k = 0;
  rer(i, 5) {
    ll a = k + (1ll << i);
    ll b = 1ll << a;
    if (b <= n)
      k += 1ll << i;
  }
  return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
  if (!mask)
    return mask = (1LL << r) - 1;
  ll x = mask & -mask; /*最下位の1*/
  ll y = mask + x;     /*連続した下の1を繰り上がらせる*/
  ll res = ((mask & ~y) / x >> 1) | y;
  if (bget(res, n))
    return mask = 0;
  else
    return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
  vi res;
  ll m = 0;
  while (nextComb(m, n, r)) {
    res.push_back(m);
  }
  return res;
}
// masの立ってるindexを見る
#define forbit(i, mas)                                                         \
  for (int forbitj = lbit(mas), forbitm = mas, i = log2(forbitj); forbitm;     \
       forbitm = forbitj ? forbitm ^ forbitj : 0, forbitj = lbit(forbitm),     \
           i = log2(forbitj))

char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
  if ('A' <= c && c <= 'Z')
    return c - 'A';
  return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
  ll res = 0;
  if (sz(v) > 18) {
    debugline("vtoi");
    deb(sz(v));
    ole();
  }
  rep(i, sz(v)) {
    res *= 10;
    res += v[i];
  }
  return res;
}
vi itov(ll i) {
  vi res;
  while (i) {
    res.push_back(i % 10);
    i /= 10;
  }
  rev(res);
  return res;
}
vi stov(string &a) {
  ll n = sz(a);
  vi ret(n);
  rep(i, n) { ret[i] = a[i] - '0'; }
  return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
  ll n = sz(a);
  vi ret(n);
  rep(i, n) ret[i] = a[i] == one;
  return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
  ll n = sz(s), m = sz(s[0]);
  vector<vector<ll>> res(n, vector<ll>(m));
  rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
  return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
  vi b;
  ll len = a.size();
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, umap<ll, ll> &map) {
  vi b;
  ll len = a.size();
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    ll v = a[i];
    a[i] = lower_bound(all(b), a[i]) - b.begin();
    map[v] = a[i];
  }
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r) {
  vi b;
  ll len = a.size();
  fora(v, a) b.push_back(v);
  fora(v, r) b.push_back(v);
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (ll i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r, vi &s) {
  vi b;
  ll len = a.size();
  fora(v, a) b.push_back(v);
  fora(v, r) b.push_back(v);
  fora(v, s) b.push_back(v);
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (ll i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  for (ll i = 0; i < sz(s); ++i)
    r[i] = lower_bound(all(b), s[i]) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vector<vi> &a) {
  vi b;
  fora(vv, a) fora(v, vv) b.push_back(v);
  sort(b);
  unique(b);
  fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vector<vector<vi>> &a) {
  vi b;
  fora(vvv, a) fora(vv, vvv) fora(v, vv) b.push_back(v);
  sort(b);
  unique(b);
  fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  ll blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
void compress(ll a[], ll len) {
  vi b;
  for (ll i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (ll i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define rlowerIndex(a, v) (upper_bound(all(a), v) - a.begin() - 1)
#define rupperIndex(a, v) (lower_bound(all(a), v) - a.begin() - 1)

template <class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) {
  auto it = lower_bound(a.begin(), a.end(), v);
  if (it == a.end())
    return banpei;
  else
    return *it;
}
template <class T, class U, class W> T lowerBound(ruiC<T> &a, U v, W banpei) {
  return lowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) {
  auto it = upper_bound(a.begin(), a.end(), v);
  if (it == a.end())
    return banpei;
  else
    return *it;
}
template <class T, class U, class W> T upperBound(ruiC<T> &a, U v, W banpei) {
  return upperBound(a.rui, v, banpei);
}
template <class T, class U, class W>
T rlowerBound(vector<T> &a, U v, W banpei) {
  auto it = upper_bound(a.begin(), a.end(), v);
  if (it == a.begin())
    return banpei;
  else {
    return *(--it);
  }
}
template <class T, class U, class W> T rlowerBound(ruiC<T> &a, U v, W banpei) {
  return rlowerBound(a.rui, v, banpei);
}
template <class T, class U, class W>
T rupperBound(vector<T> &a, U v, W banpei) {
  auto it = lower_bound(a.begin(), a.end(), v);
  if (it == a.begin())
    return banpei;
  else {
    return *(--it);
  }
}
template <class T, class U, class W> T rupperBound(ruiC<T> &a, U v, W banpei) {
  return rupperBound(a.rui, v, banpei);
}
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))

// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
  int n = sz(a);
  vi tail(n + 1, MAX(T));
  rep(i, n) {
    int id = lowerIndex(tail, a[i]); /**/
    tail[id] = a[i];
  }
  return lowerIndex(tail, MAX(T));
}
template <class T> int lis_eq(vector<T> &a) {
  int n = sz(a);
  vi tail(n + 1, MAX(T));
  rep(i, n) {
    int id = upperIndex(tail, a[i]); /**/
    tail[id] = a[i];
  }
  return lowerIndex(tail, MAX(T));
}

// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
  auto ret = m.lower_bound(k);
  while (ret != m.end() && (*ret).second == 0) {
    ret = m.erase(ret);
  }
  return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
  auto ret = m.upper_bound(k);
  while (ret != m.end() && (*ret).second == 0) {
    ret = m.erase(ret);
  }
  return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
  auto ret = upper_map(m, k);
  assert(ret != m.begin());
  ret--;
  while (1) {
    if ((*ret).second != 0)
      break;
    assert(ret != m.begin());
    auto next = ret;
    --next;
    m.erase(ret);
    ret = next;
  }
  return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
  auto ret = lower_map(m, k);
  assert(ret != m.begin());
  ret--;
  while (1) {
    if ((*ret).second != 0)
      break;
    assert(ret != m.begin());
    auto next = ret;
    --next;
    m.erase(ret);
    ret = next;
  }
  return ret;
}

template <class... T> void fin(T... s) {
  out(s...);
  exit(0);
}

// 便利 数学 math
// sub ⊂ top
bool subset(int sub, int top) { return (sub & top) == sub; }
//-180 ~ 180 degree
double atand(double h, double w) { return atan2(h, w) / PI * 180; }
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {
  if (m < 0)
    m *= -1;
  return (a % m + m) % m;
}
ll pow(ll a) { return a * a; };
ll fact(ll v) { return v <= 1 ? 1 : v * fact(v - 1); }
dou factd(int v) {
  static vd fact(2, 1);
  if (sz(fact) <= v) {
    rep(i, sz(fact), v + 1) { fact.push_back(fact.back() * i); }
  }
  return fact[v];
}

ll comi(ll n, ll r) {
  assert(n < 100);
  static vvi(pas, 100, 100);
  if (pas[0][0])
    return pas[n][r];
  pas[0][0] = 1;
  rep(i, 1, 100) {
    pas[i][0] = 1;
    rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
  }
  return pas[n][r];
}
double comd2(ll n, ll r) {
  static vvd(comb, 2020, 2020);
  if (comb[0][0] == 0) {
    comb[0][0] = 1;
    rep(i, 2000) {
      comb[i + 1][0] = 1;
      rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
    }
  }
  return comb[n][r];
}
double comd(int n, int r) {
  if (r < 0 || r > n)
    return 0;
  if (n < 2020)
    return comd2(n, r);
  static vd fact(2, 1);
  if (sz(fact) <= n) {
    rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
  }
  return fact[n] / fact[n - r] / fact[r];
}

ll gcd(ll a, ll b) {
  while (b)
    a %= b, swap(a, b);
  return abs(a);
}
ll gcd(vi b) {
  ll res = b[0];
  rep(i, 1, sz(b)) res = gcd(b[i], res);
  return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
  ll res = a[0];
  rep(i, 1, sz(a)) res = lcm(a[i], res);
  return res;
}
ll ceil(ll a, ll b) {
  if (b == 0) {
    debugline("ceil");
    deb(a, b);
    ole();
    return -1;
  } else if (a < 0) {
    return 0;
  } else {
    return (a + b - 1) / b;
  }
}

ll sig0(ll t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
// ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {
  if (s > t)
    swap(s, t);
  return sig0(t - s) + s * (t - s + 1);
}

#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) {
  assert(((v - st) % ad) == 0);
  return (v - st) / ad;
}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad; }

// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) {
  if (st >= v)
    return st;
  return (v - st + ad - 1) / ad * ad + st;
}
// 第何項か
ll lower_tosa_i(ll st, ll ad, ll v) {
  if (st >= v)
    return 0;
  return (v - st + ad - 1) / ad;
}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }

// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
  if (a < 0) {
    debugline("sqrt");
    deb(a);
    ole();
  }
  ll res = (ll)std::sqrt(a);
  while (res * res < a)
    ++res;
  return res;
}
double log(double e, double x) { return log(x) / log(e); }

/*@formatter:off*/

// 機能拡張
#define dtie(a, b)                                                             \
  int a, b;                                                                    \
  tie(a, b)
template <class T, class U> string to_string(T a, U b) {
  string res = "";
  res += a;
  res += b;
  return res;
}
template <class T, class U, class V> string to_string(T a, U b, V c) {
  string res = "";
  res += a;
  res += b;
  res += c;
  return res;
}
template <class T, class U, class V, class W>
string to_string(T a, U b, V c, W d) {
  string res = "";
  res += a;
  res += b;
  res += c;
  res += d;
  return res;
}
template <class T, class U, class V, class W, class X>
string to_string(T a, U b, V c, W d, X e) {
  string res = "";
  res += a;
  res += b;
  res += c;
  res += d;
  res += e;
  return res;
}

constexpr int bsetlen = k5 * 2;
// constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] < b[i])
      return true;
    if (a[i] > b[i])
      return false;
  }
  return false;
}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] > b[i])
      return true;
    if (a[i] < b[i])
      return false;
  }
  return false;
}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] < b[i])
      return true;
    if (a[i] > b[i])
      return false;
  }
  return true;
}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
  rer(i, bsetlen - 1) {
    if (a[i] > b[i])
      return true;
    if (a[i] < b[i])
      return false;
  }
  return true;
}
string operator~(string &a) {
  string res = a;
  for (auto &&c : res) {
    if (c == '0')
      c = '1';
    else if (c == '1')
      c = '0';
    else {
      cerr << "cant ~" << a << "must bit" << endl;
      exit(0);
    }
  }
  return res;
}
ostream &operator<<(ostream &os, bset &a) {
  bitset<10> b;
  vi list;
  rep(i, bsetlen) {
    if (a[i])
      list.push_back(i), b[i] = 1;
  }
  os << b << ", " << list;
  return os;
}
int hbiti(bset &a) {
  rer(i, bsetlen) {
    if (a[i])
      return i;
  }
  return -1;
}
#define hk(a, b, c) (a <= b && b < c)

// O(N/64)
bset nap(bset &a, int v) {
  bset r = a | a << v;
  return r;
}
bset nap(bset &a, bset &v) {
  bset r = a;
  rep(i, bsetlen) {
    if (v[i])
      r |= a << i;
  }
  return r;
}

template <class T> void seth(vector<vector<T>> &S, int w, vector<T> &v) {
  assert(sz(S) == sz(v));
  assert(w < sz(S[0]));
  rep(h, sz(S)) { S[h][w] = v[h]; }
}

template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
  a.fi += b.fi;
  a.se += b.se;
}
template <class T, class U> pair<T, U> operator+(pair<T, U> &a, pair<T, U> &b) {
  return pair<T, U>(a.fi + b.fi, a.se + b.se);
}

template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
  basic_string<CharT, Traits, Alloc> str(lhs);
  str.append(to_string(rv));
  return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
  lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
  basic_string<CharT, Traits, Alloc> str(lhs);
  str.append(to_string(rv));
  return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
  lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
  auto bek = s;
  s = "";
  for (; num; num >>= 1) {
    if (num & 1) {
      s += bek;
    }
    bek += bek;
  }
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
  a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
  fora(d, v) a.push(d);
  return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
  a.push(v);
  return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
  a.push(v);
  return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
  fora(d, v) a.insert(d);
  return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
  return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
  return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
  return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
  a.insert(v);
  return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
  a.push_back(v);
  return a;
}
template <class T, class U> vector<T> operator+(vector<T> &a, U v) {
  vector<T> ret = a;
  ret += v;
  return ret;
}
template <class T, class U> vector<T> operator+(U v, vector<T> &a) {
  vector<T> ret = a;
  ret.insert(ret.begin(), v);
  return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
  vector<T> ret;
  ret = a;
  fora(v, b) ret += v;
  return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
  rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
    a.push_back(b[i]);
  }
  return a;
}
template <class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) {
  fora(bv, b) { a[bv.first] += bv.second; }
  return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
  if (sz(a) != sz(b)) {
    debugline("vector<T> operator-=");
    deb(a);
    deb(b);
    exit(0);
  }
  rep(i, sz(a)) a[i] -= b[i];
  return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
  if (sz(a) != sz(b)) {
    debugline("vector<T> operator-");
    deb(a);
    deb(b);
    ole();
  }
  vector<T> res(sz(a));
  rep(i, sz(a)) res[i] = a[i] - b[i];
  return res;
}
template <class T, class U> void operator*=(vector<T> &a, U b) {
  vector<T> ta = a;
  rep(b - 1) { a += ta; }
}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
  v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
  v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
  v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
  v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
  v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
  for (auto &&va : list)
    v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
  for (auto &&va : list)
    v.insert(va);
}
vector<string> split(const string a, const char deli) {
  string b = a + deli;
  ll l = 0, r = 0, n = b.size();
  vector<string> res;
  rep(i, n) {
    if (b[i] == deli) {
      r = i;
      if (l < r)
        res.push_back(b.substr(l, r - l));
      l = i + 1;
    }
  }
  return res;
}
vector<string> split(const string a, const string deli) {
  vector<string> res;
  ll kn = sz(deli);
  std::string::size_type Pos(a.find(deli));
  ll l = 0;
  while (Pos != std::string::npos) {
    if (Pos - l)
      res.push_back(a.substr(l, Pos - l));
    l = Pos + kn;
    Pos = a.find(deli, Pos + kn);
  }
  if (sz(a) - l)
    res.push_back(a.substr(l, sz(a) - l));
  return res;
}
void yn(bool a) {
  if (a)
    cout << "yes" << endl;
  else
    cout << "no" << endl;
}
void Yn(bool a) {
  if (a)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
void YN(bool a) {
  if (a)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
}
void fyn(bool a) {
  if (a)
    cout << "yes" << endl;
  else
    cout << "no" << endl;
  exit(0);
}
void fYn(bool a) {
  if (a)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
  exit(0);
}
void fYN(bool a) {
  if (a)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
  exit(0);
}
void fAb(bool a) {
  if (a)
    cout << "Alice" << endl;
  else
    cout << "Bob";
}
void Possible(bool a) {
  if (a)
    cout << "Possible" << endl;
  else
    cout << "Impossible" << endl;
  exit(0);
}
void POSSIBLE(bool a) {
  if (a)
    cout << "POSSIBLE" << endl;
  else
    cout << "IMPOSSIBLE" << endl;
  exit(0);
}
template <typename T> class fixed_point : T {
public:
  explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
  template <typename... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return T::operator()(*this, std::forward<Args>(args)...);
  }
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
  return fixed_point<T>{std::forward<T>(t)};
}

// 未分類
// 0,2,1 1番目と2番目の次元を入れ替える
template <class T>
auto irekae(vector<vector<vector<T>>> &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c)                                            \
  resize(res, a, b, c);                                                        \
  rep(i, a) rep(j, b) rep(k, c)
  vector<vector<vector<T>>> res;
  if (x == 0 && y == 1 && z == 2) {
    res = A;
  } else if (x == 0 && y == 2 && z == 1) {
    irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) {
      res[i][j][k] = A[i][k][j];
    }
  } else if (x == 1 && y == 0 && z == 2) {
    irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) {
      res[i][j][k] = A[j][i][k];
    }
  } else if (x == 1 && y == 2 && z == 0) {
    irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) {
      res[i][j][k] = A[k][i][j];
    }
  } else if (x == 2 && y == 0 && z == 1) {
    irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) {
      res[i][j][k] = A[j][k][i];
    }
  } else if (x == 2 && y == 1 && z == 0) {
    irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) {
      res[i][j][k] = A[k][j][i];
    }
  }
  return res;
#undef irekae_resize_loop
}
template <class T> auto irekae(vector<vector<T>> &A, int i = 1, int j = 0) {
  vvt(res, sz(A[0]), sz(A));
  rep(i, sz(A)) {
    rep(j, sz(A[0])) { res[j][i] = A[i][j]; }
  }
  return res;
}
// tou分割する
template <typename T> vector<vector<T>> cut(vector<T> &a, int tou = 2) {
  int N = sz(a);
  vector<vector<T>> res(tou);
  int hab = N / tou;
  vi lens(tou, hab);
  rep(i, N % tou) { lens[tou - 1 - i]++; }
  int l = 0;
  rep(i, tou) {
    int len = lens[i];
    int r = l + len;
    res[i].resize(len);
    std::copy(a.begin() + l, a.begin() + r, res[i].begin());
    l = r;
  }
  return res;
}
// 長さn毎に分割する
template <typename T> vector<vector<T>> cutn(vector<T> &a, int len) {
  int N = sz(a);
  vector<vector<T>> res(ceil(N, len));
  vi lens(N / len, len);
  if (N % len)
    lens.push_back(N % len);
  int l = 0;
  rep(i, sz(lens)) {
    int len = lens[i];
    int r = l + len;
    res[i].resize(len);
    std::copy(a.begin() + l, a.begin() + r, res[i].begin());
    l = r;
  }
  return res;
}
vi inds_(vi &a) {
  int n = sz(a);
  vb was(n);
  vi res(n);
  rep(i, n) {
    assert(!was[a[i]]);
    res[a[i]] = i;
    was[a[i]] = true;
  }
  return res;
}

//@起動時
struct initon {
  initon() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    srand((unsigned)clock() + (unsigned)time(NULL));
  };
} initonv;
#define pre prev
#define nex next

// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
// 右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {
  while (++i < 4) {
    if (inside(h + h4[i], w + w4[i], H, W))
      return i;
  }
  return i;
}
#define mei(nh, nw, h, w)                                                      \
  for (int i = mei_inc(h, w, H, W, -1), nh = i < 4 ? h + h4[i] : 0,            \
           nw = i < 4 ? w + w4[i] : 0;                                         \
       i < 4; i = mei_inc(h, w, H, W, i), nh = h + h4[i], nw = w + w4[i])

// グラフ内で #undef getid
// #define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) (h * W + w)
#define getid_1(p) (p.first * W + p.second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
// #define set_shuffle() std::random_device seed_gen;std::mt19937
// engine(seed_gen()) #define shuffle(a) std::shuffle((a).begin(), (a).end(),
// engine); 1980 開始からtime ms経っていたらtrue
bool timeup(int time) {
  auto end_time = system_clock::now();
  auto part = duration_cast<milliseconds>(end_time - start_time);
  auto lim = milliseconds(time);
  return part >= lim;
}
void set_time() { past_time = system_clock::now(); }
// MS型(millisecqnds)で返る
// set_timeをしてからの時間
auto calc_time_milli() {
  auto now = system_clock::now();
  auto part = duration_cast<milliseconds>(now - past_time);
  return part;
}
auto calc_time_micro() {
  auto now = system_clock::now();
  auto part = duration_cast<microseconds>(now - past_time);
  return part;
}
auto calc_time_nano() {
  auto now = system_clock::now();
  auto part = duration_cast<nanoseconds>(now - past_time);
  return part;
}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS = std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {
  if (b < nanoseconds(1)) {
    return a / nanoseconds(1);
  }
  int v = a / b;
  return v;
}
// set_time();
// rep(i,lim)shori

// lim*=time_nanbai();
// rep(i,lim)shoriと使う
// 全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {
  auto dec = duration_cast<nanoseconds>(past_time - start_time);
  auto part = calc_time_nano();
  auto can_time = nanoseconds(milli * 1000 * 1000);
  can_time -= part;
  can_time -= dec;
  return div(can_time, part);
}
/*@formatter:on*/
// vectorで取れる要素数
// bool=> 1e9 * 8.32
// int => 1e8 * 2.6
// ll  => 1e8 * 1.3
// 3次元以上取るとメモリがヤバい
// static配列を使う

vvc(ba);
ll N, M, H, W;
vi A, B, C;
#undef getid
/*@formatter:off*/
#define forg(gi, ve)                                                           \
  for (ll gi = 0, forglim = ve.size(), f, t, c;                                \
       gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
#define fort(gi, ve)                                                           \
  for (ll gi = 0, f, t, c, wasp = (p != -1 && ve[gi].t == p) ? 1 : 0;          \
       (wasp = wasp                         ? 1                                \
               : (p != -1 && ve[gi].t == p) ? 1                                \
                                            : 0,                               \
       gi + wasp < ve.size()) &&                                               \
       (tie(f, t, c) =                                                         \
            wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c)        \
                 : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c),                   \
                  true);                                                       \
       ++gi)
#define fore(gi, ve)                                                           \
  for (ll gi = 0, forglim = ve.size(), f, t, c;                                \
       gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)

template <class T> struct edge_ {
  int f, t;
  T c;
  edge_(int f, int t, T c = 1) : f(f), t(t), c(c) {}
  bool operator<(const edge_ &b) const { return c < b.c; }
  bool operator>(const edge_ &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge_<T> &e) {
  os << e.f << " " << e.t << " " << e.c;
  return os;
}
template <typename T> class graph {
public:
  vector<vector<edge_<T>>> g;
  vector<edge_<T>> edges;
  int n;
  explicit graph(int n) : n(n) { g.resize(n); }
  void clear() { g.clear(), edges.clear(); }
  void resize(int n) {
    this->n = n;
    g.resize(n);
  }
  int size() { return n; }
  vector<edge_<T>> &operator[](int i) { return g[i]; }
  virtual void add(int f, int t, T c) = 0;
  virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
  using graph<T>::g;
  using graph<T>::n;
  using graph<T>::edges;
  explicit digraph(int n) : graph<T>(n) {}
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("digraph add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    edges.emplace_back(f, t, c); // edgesを使わないなら消せる
  }
  void ing(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t;
      cin >> f >> t;
      f -= minus;
      t -= minus;
      add(f, t);
    }
  }
  void ingc(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t, c;
      cin >> f >> t >> c;
      f -= minus;
      t -= minus;
      add(f, t, c);
    }
  }
  void set_edges() override {
    if (sz(edges))
      return;
    rep(i, n) fora(e, g[i]) edges.push_back(e);
  }
};
template <class T = int> class undigraph : public graph<T> {
public:
  using graph<T>::g;
  using graph<T>::n;
  using graph<T>::edges;
  explicit undigraph(int n) : graph<T>(n) {}
  // f < t
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("undigraph add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    g[t].emplace_back(t, f, c);
    edges.emplace_back(f, t, c); // edgesを使わないなら消せる
    edges.emplace_back(t, f, c);
  }
  void add(edge_<T> &e) {
    int f = e.f, t = e.t;
    T c = e.c;
    add(f, t, c);
  }
  void ing(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t;
      cin >> f >> t;
      f -= minus;
      t -= minus;
      add(f, t);
    }
  }
  void ingc(int n, int m, int minus = 1) {
    this->resize(n);
    rep(i, m) {
      int f, t, c;
      cin >> f >> t >> c;
      f -= minus;
      t -= minus;
      add(f, t, c);
    }
  }
  void set_edges() override {
    if (sz(edges))
      return;
    rep(i, n) fora(e, g[i]) edges.push_back(e);
  }
};
#define dijkstra_path dis_path
template <class T>
vi dis_path(digraph<T> &g, vector<T> &dis, int s, int t, int init_value) {
  assert(dis[t] != init_value);
  auto rg = rev(g);
  int now = t;
  vi path;
  path.push_back(now);
  T cost = 0;
  while (now != s) {
    rep(gi, sz(rg[now])) {
      int m = rg[now][gi].t;
      if (dis[m] == init_value)
        continue;
      if (dis[m] + rg[now][gi].c + cost == dis[t]) {
        cost += rg[now][gi].c;
        now = m;
        break;
      }
    }
    path.push_back(now);
  }
  rev(path);
  return path;
}
template <class T>
vi dis_path(undigraph<T> &g, vector<T> &dis, int s, int t, int init_value) {
  assert(dis[t] != init_value);
  int now = t;
  vi path;
  path.push_back(now);
  T cost = 0;
  while (now != s) {
    rep(gi, sz(g[now])) {
      int m = g[now][gi].t;
      if (dis[m] == init_value)
        continue;
      if (dis[m] + g[now][gi].c + cost == dis[t]) {
        cost += g[now][gi].c;
        now = m;
        break;
      }
    }
    path.push_back(now);
  }
  rev(path);
  return path;
}
template <class T>
vi dis_path(digraph<T> &g, vector<vector<T>> &dis, int s, int t,
            int init_value) {
  return dis_path(g, dis[s], s, t, init_value);
}
template <class T>
vi dis_path(undigraph<T> &g, vector<vector<T>> &dis, int s, int t,
            int init_value) {
  return dis_path(g, dis[s], s, t, init_value);
}
// O(N^2)
template <class T> vector<T> dijkstra_mitu(graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra_mitu");
    deb(s, g.n);
    ole();
  }
  int n = g.n;
  int initValue = MAX(int);
  vector<T> dis(n, initValue);
  dis[s] = 0;
  vb used(n);
  while (true) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || dis[u] < dis[v]))
        v = u;
    }
    if (v == -1)
      break;
    if (dis[v] == initValue)
      break;
    used[v] = true;
    rep(u, sz(g[v])) {
      auto e = g[v][u];
      dis[e.t] = min(dis[e.t], dis[v] + e.c);
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis) {
    if (d == initValue) {
      d = init_value;
    }
  }
  return dis;
}
template <typename T> struct radixheap {
  vector<pair<u64, T>> v[65];
  u64 size, last;
  radixheap() : size(0), last(0) {}
  bool empty() const { return size == 0; }
  int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
  void push(u64 key, const T &value) {
    ++size;
    v[getbit(key ^ last)].emplace_back(key, value);
  }
  pair<u64, T> pop() {
    if (v[0].empty()) {
      int idx = 1;
      while (v[idx].empty())
        ++idx;
      last = min_element(begin(v[idx]), end(v[idx]))->first;
      for (auto &p : v[idx])
        v[getbit(p.first ^ last)].emplace_back(p);
      v[idx].clear();
    }
    --size;
    auto ret = v[0].back();
    v[0].pop_back();
    return ret;
  }
};
/*radix_heap こっちの方が早い*/
// O((N+M) log N)
vi dijkstra(graph<int> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  } /*O((N+M) log N) vs O(N^2)*/
  if ((g.n + sz(g.edges)) * log2(N) > g.n * g.n) {
    return dijkstra_mitu(g, s, init_value);
  }
  int initValue = MAX(int);
  vi dis(g.n, initValue);
  radixheap<int> q;
  dis[s] = 0;
  q.push(0, s);
  while (!q.empty()) {
    int nowc, i;
    tie(nowc, i) = q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      int c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        q.push(dis[to], to);
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return dis;
}
template <class T>
vector<T> dijkstra_normal(graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  }
  if ((g.n + sz(g.edges)) * 20 > g.n * g.n) {
    return dijkstra_mitu(g, s, init_value);
  }
  T initValue = MAX(T);
  vector<T> dis(g.n, initValue);
  priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
  dis[s] = 0;
  q.emplace(0, s);
  while (q.size()) {
    T nowc = q.top().fi;
    int i = q.top().se;
    q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      T c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        q.emplace(dis[to], to);
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return dis;
}
template <class T> vector<T> dijkstra_01(graph<T> &g, int s, int init_value) {
  int N = g.n;
  vi dis(N, linf);
  dis[s] = 0;
  deque<int> q;
  q.push_back(s);
  vb was(N);
  while (!q.empty()) {
    int f = q.front();
    q.pop_front();
    if (was[f])
      continue;
    was[f] = true;
    fora(e, g[f]) {
      if (dis[e.t] > dis[f] + e.c) {
        if (e.c) {
          dis[e.t] = dis[f] + 1;
          q.push_back(e.t);
        } else {
          dis[e.t] = dis[f];
          q.push_front(e.t);
        }
      }
    }
  }
  rep(i, N) if (dis[i] == linf) dis[i] = init_value;
  return dis;
}
// dijkstra_cou<mint> : 数える型で書く return vp(dis,cou)
template <class COU, class T = int>
auto dijkstra_cou(const graph<T> &g, int s, int init_value) {
  if (!(0 <= s && s < g.n)) {
    debugline("dijkstra");
    deb(s, g.n);
    ole();
  }
  err("count by type COU ");
  err("int or mint");
  T initValue = MAX(T);
  vector<T> dis(g.n, initValue);
  vector<COU> cou(g.n);
  cou[s] = 1;
  priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
  dis[s] = 0;
  q.emplace(0, s);
  while (q.size()) {
    T nowc = q.top().fi;
    int i = q.top().se;
    q.pop();
    if (dis[i] != nowc)
      continue;
    for (auto &&e : g.g[i]) {
      int to = e.t;
      T c = nowc + e.c;
      if (dis[to] > c) {
        dis[to] = c;
        cou[to] = cou[e.f];
        q.emplace(dis[to], to);
      } else if (dis[to] == c) {
        cou[to] += cou[e.f];
      }
    }
  } /*基本、たどり着かないなら-1*/
  for (auto &&d : dis)
    if (d == initValue)
      d = init_value;
  return vtop(dis, cou);
}
// 密グラフの時、warshallに投げる
template <class T>
vector<vector<T>> dijkstra_all(const graph<T> &g, int init_value) {
  int n = g.n;
  assert(n < 1e4);
  if (n * n < (n + sz(g.edges)) * 14) { /*O(N^3) vs O(N (N+M)log N)*/
    return warshall(g, init_value);
  }
  vector<vector<T>> dis(n);
  rep(i, n) { dis[i] = dijkstra(g, i, init_value); }
  return dis;
}
// コストを無限に減らせる := -linf
// たどり着けない := linf
template <class T> vector<T> bell(graph<T> &g, int s) {
  if (g.n >= 1e4) {
    cout << "bell size too big" << endl;
    exit(0);
  }
  vector<T> res(g.n, linf);
  res[s] = 0;
  vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく */
  fix([&](auto ds, int p, int i) -> void {
    if (can[i])
      return;
    can[i] = true;
    forg(gi, g[i]) if (t != p) ds(i, t);
  })(-1, 0);
  vector<edge_<T>> es;
  fora(e, g.edges) {
    if (can[e.f])
      es += e;
  }
  rep(i, g.n) {
    bool upd = false;
    fora(e, es) {
      if (res[e.f] != linf && res[e.t] > res[e.f] + e.c) {
        upd = true;
        res[e.t] = res[e.f] + e.c;
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n * 2) {
    bool upd = 0;
    fora(e, g.edges) {
      if (res[e.f] != linf && res[e.t] != -linf && res[e.t] > res[e.f] + e.c) {
        upd = 1;
        res[e.t] = -linf;
      }
    }
    if (!upd)
      break;
  }
  return res;
}
// コストを無限に増やせる := linf
// たどり着けない := -linf
template <class T> vector<T> bell_far(graph<T> &g, int s) {
  if (g.n >= 1e4) {
    cout << "bell_far size too big" << endl;
    exit(0);
  }
  vector<T> res(g.n, linf);
  res[s] = 0;
  vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく*/
  fix([&](auto ds, int p, int i) -> void {
    if (can[i])
      return;
    can[i] = true;
    forg(gi, g[i]) if (t != p) ds(i, t);
  })(-1, 0);
  vector<edge_<T>> es;
  fora(e, g.edges) {
    if (can[e.f])
      es += e;
  }
  rep(i, g.n) {
    bool upd = false;
    fora(e, es) {
      if (res[e.f] != linf && res[e.t] > res[e.f] - e.c) { /*-c*/
        upd = true;
        res[e.t] = res[e.f] - e.c; /*-c*/
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n * 2) {
    bool upd = 0;
    fora(e, g.edges) {
      if (res[e.f] != linf && res[e.t] != -linf &&
          res[e.t] > res[e.f] - e.c) { /*-c*/
        upd = 1;
        res[e.t] = -linf;
      }
    }
    if (!upd)
      break;
  }
  rep(i, g.n) res[i] *= -1;
  return res;
}
template <class T> vector<vector<T>> warshall(graph<T> &g, int init_value) {
  int n = g.n;
  assert(n < 1e4);
  vector<vector<T>> dis(n, vector<T>(n, linf));
  rep(i, n) fora(e, g.g[i]) {
    if (dis[e.f][e.t] > e.c) {
      dis[e.f][e.t] = e.c;
    }
  }
  rep(i, n) dis[i][i] = 0;
  rep(k, n) rep(i, n) rep(j, n) {
    if (dis[i][j] > dis[i][k] + dis[k][j]) {
      dis[i][j] = dis[i][k] + dis[k][j];
    }
  }
  rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = init_value;
  return dis;
}
template <class T> class MinOp {
public:
  T operator()(T a, T b) { return min(a, b); }
};
template <typename OpFunc> struct SparseTable {
  OpFunc op;
  signed size;
  vector<signed> lg;
  vector<vector<pair<signed, signed>>> table;
  void init(vector<pair<signed, signed>> &array, OpFunc opfunc) {
    signed n = array.size();
    op = opfunc;
    lg.assign(n + 1, 0);
    for (signed i = 1; i <= n; i++) {
      lg[i] = 31 - __builtin_clz(i);
    }
    table.assign(lg[n] + 1, array);
    for (signed i = 1; i <= lg[n]; i++) {
      for (signed j = 0; j < n; j++) {
        if (j + (1 << (i - 1)) < n) {
          table[i][j] = op(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
        } else {
          table[i][j] = table[i - 1][j];
        }
      }
    }
  }
  pair<signed, signed> query(signed l, signed r) {
    assert(l < r);
    return op(table[lg[r - l]][l], table[lg[r - l]][r - (1 << lg[r - l])]);
  }
};
struct PMORMQ {
  vector<signed> a;
  SparseTable<MinOp<pair<signed, signed>>> sparse_table;
  vector<vector<vector<signed>>> lookup_table;
  vector<signed> block_type;
  signed block_size, n_block;
  void init(vector<signed> &array) {
    a = array;
    signed n = a.size();
    block_size = std::max(1, (31 - __builtin_clz(n)) / 2);
    while (n % block_size != 0) {
      a.push_back(a.back() + 1);
      n++;
    }
    n_block = n / block_size;
    vector<pair<signed, signed>> b(n_block, make_pair(INT_MAX, INT_MAX));
    for (signed i = 0; i < n; i++) {
      b[i / block_size] = min(b[i / block_size], make_pair(a[i], i));
    }
    sparse_table.init(b, MinOp<pair<signed, signed>>());
    block_type.assign(n_block, 0);
    for (signed i = 0; i < n_block; i++) {
      signed cur = 0;
      for (signed j = 0; j < block_size - 1; j++) {
        signed ind = i * block_size + j;
        if (a[ind] < a[ind + 1]) {
          cur |= 1 << j;
        }
      }
      block_type[i] = cur;
    }
    lookup_table.assign(
        1 << (block_size - 1),
        vector<vector<signed>>(block_size, vector<signed>(block_size + 1)));
    for (signed i = 0; i < (1 << (block_size - 1)); i++) {
      for (signed j = 0; j < block_size; j++) {
        signed res = 0;
        signed cur = 0;
        signed pos = j;
        for (signed k = j + 1; k <= block_size; k++) {
          lookup_table[i][j][k] = pos;
          if (i & (1 << (k - 1))) {
            cur++;
          } else {
            cur--;
          }
          if (res > cur) {
            pos = k;
            res = cur;
          }
        }
      }
    }
  }
  signed query(signed l, signed r) {
    assert(l < r);
    signed lb = l / block_size;
    signed rb = r / block_size;
    if (lb == rb) {
      return lb * block_size +
             lookup_table[block_type[lb]][l % block_size][r % block_size];
    }
    signed pl = lb * block_size +
                lookup_table[block_type[lb]][l % block_size][block_size];
    signed pr =
        rb * block_size + lookup_table[block_type[rb]][0][r % block_size];
    signed pos = pl;
    if (r % block_size > 0 && a[pl] > a[pr]) {
      pos = pr;
    }
    if (lb + 1 == rb) {
      return pos;
    }
    signed spv = sparse_table.query(lb + 1, rb).second;
    if (a[pos] > a[spv]) {
      return spv;
    }
    return pos;
  }
};

template <class T = int> class tree : public undigraph<T> {
  PMORMQ rmq;
  int cnt;
  vector<signed> id, in;
  bool never = true;
  bool never_hld = true;
  void dfs(int x, int p, int d, int dis = 0) {
    id[cnt] = x;
    par_[x] = p;
    rmq_dep.push_back(d);
    disv[x] = dis;
    in[x] = cnt++;
    forg(gi, g[x]) {
      if (t == p) {
        continue;
      }
      dfs(t, x, d + 1, dis + c);
      id[cnt] = x;
      rmq_dep.push_back(d);
      cnt++;
    }
  }
  void precalc() {
    never = false;
    cnt = 0;
    rmq_dep.clear();
    disv.assign(n, 0);
    in.assign(n, -1);
    id.assign(2 * n - 1, -1);
    par_.assign(n, -1);
    dfs(root, -1, 0);
    rmq.init(rmq_dep);
#ifdef _DEBUG
    if (n >= 100)
      return;
    cerr << "---tree---" << endl;
    rep(i, n) {
      if (!(i == root || sz(g[i]) > 1))
        continue;
      cerr << i << " -> ";
      vi ts;
      forg(gi, g[i]) {
        if (t != par_[i])
          ts.push_back(t);
      }
      rep(i, sz(ts) - 1) cerr << ts[i] << ", ";
      if (sz(ts))
        cerr << ts.back() << endl;
    }
    cerr << endl;
#endif
  }
  int pos;
  void hld_build() {
    never_hld = false;
    if (never)
      precalc();
    g.resize(n);
    vid.resize(n, -1);
    head.resize(n);
    heavy.resize(n, -1);
    depth.resize(n);
    inv.resize(n);
    subl.resize(n);
    subr.resize(n);
    dfs(root, -1);
    t = 0;
    dfs_hld(root);
#ifdef _DEBUG
    if (n >= 100)
      return;
    cerr << "---hld_index---" << endl;
    vi inds;
    rep(i, n) if (sz(g[i])) inds.push_back(i);
    rep(i, sz(inds)) {
      str s = tos(bel(inds[i]));
      cerr << std::right << std::setw(sz(s) + (i ? 1 : 0)) << inds[i];
    }
    cerr << endl;
    rep(i, sz(inds)) { cerr << bel(inds[i]) << " "; }
    cerr << endl << endl;
    cerr << "---hld_edge_index---" << endl;
    fora(e, edges) {
      if (e.f <= e.t)
        cerr << e.f << "-" << e.t << " " << bel(e) << endl;
    }
    cerr << endl << endl;
    cerr << "!!query!! edge or not edge carefull!!" << endl;
#endif
  }
  int dfs(int curr, int prev) {
    int sub = 1, max_sub = 0;
    heavy[curr] = -1;
    forg(i, g[curr]) {
      int next = t;
      if (next != prev) {
        depth[next] = depth[curr] + 1;
        int sub_next = dfs(next, curr);
        sub += sub_next;
        if (max_sub < sub_next)
          max_sub = sub_next, heavy[curr] = next;
      }
    }
    return sub;
  }
  int t = 0;
#ifndef __CLION_IDE__
  void dfs_hld(int v = 0) {
    vid[v] = subl[v] = t;
    t++;
    inv[subl[v]] = v;
    if (0 <= heavy[v]) {
      head[heavy[v]] = head[v];
      dfs_hld(heavy[v]);
    }
    forg(i, g[v]) if (depth[v] < depth[t]) if (t != heavy[v]) {
      head[t] = t;
      dfs_hld(t);
    }
    subr[v] = t;
  }
#endif //__CLION_IDE__
  vector<signed> rmq_dep;
  vi par_, depth, disv;
  vi childs;
  vi par_id_; // 親への辺のidを持つ
  vvi(ids_);  // 隣接で辺のidを持つ
public:
  using undigraph<T>::g;
  using undigraph<T>::n;
  using undigraph<T>::edges;
  int root;
  //(f,t)と(t,f)は同じidを持ち、[0,n-1]でadd順に割り振られる

  // 部分木の  [左端、右端)  index
  // 部分木の辺に加算する場合
  // add(subl[i],subr[i],x)
  // add(sub[i],sub[i+1],-x)
  vector<int> vid, head, heavy, inv, subl, subr;

  tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
  void change_root(int roo) {
    root = roo;
    precalc();
  }
  int lca(int a, int b) {
    if (never)
      precalc();
    int x = in[a];
    int y = in[b];
    if (x > y) {
      swap(x, y);
    }
    int pos = rmq.query(x, y + 1);
    return id[pos];
  }
  int dis(int a, int b) {
    if (never)
      precalc();
    int x = in[a];
    int y = in[b];
    if (x > y) {
      swap(x, y);
    }
    int pos = rmq.query(x, y + 1);
    int p = id[pos];
    return disv[a] + disv[b] - disv[p] * 2;
  }
  int dep(int a) {
    if (never)
      precalc();
    return disv[a];
  }
  int par(int a) {
    if (never)
      precalc();
    return par_[a];
  }
  bool isleaf(int i) {
    if (never)
      precalc();
    return (sz(g[i]) == 1 && i != root);
  }
  vi child(int r) {
    vi res;
    res.push_back(r);
    queue<int> q;
    q.push(r);
    while (!q.empty()) {
      int i = q.front();
      res.push_back(i);
      q.pop();
      forg(gi, g[i]) {
        if (t != par(i))
          q.push(t);
      }
    }
    return res;
  }
  vb child_ex(int r) {
    vb res(n);
    res[r] = true;
    queue<int> q;
    q.push(r);
    while (!q.empty()) {
      int i = q.front();
      res[i] = true;
      q.pop();
      forg(gi, g[i]) {
        if (t != par(i))
          q.push(t);
      }
    }
    return res;
  }
  int dfs_count_subtree(int p, int i) {
    childs[i] = 1;
    fort(gi, g[i]) { childs[i] += dfs_count_subtree(i, t); }
    return childs[i];
  }
#define count_child count_subtree
  int count_subtree(int f) {
    if (sz(childs) == 0) {
      if (never)
        precalc();
      childs.resize(n);
      dfs_count_subtree(-1, root);
    }
    return childs[f];
  }
  // fからtの辺を切った時のtの大きさ
  int count_subtree(int f, int t) {
    if (par(f) == t) {
      return n - count_subtree(f);
    } else {
      return count_subtree(t);
    }
  }
  vi path(int a, int b) {
    vi res;
    for_each_l(a, b, [&](int i) { res.push_back(i); });
    return res;
  }
  int par_id(int i) {
    if (sz(par_id_) == 0) {
      pathe(0, 0);
    }
    return par_id_[i];
  }
  int ids(int f, int i) {
    if (sz(ids_) == 0) {
      pathe(0, 0);
    }
    return ids_[f][i];
  }
  edge_<T> edge(int id) { return edges[id << 1]; }
  // pathに含まれる辺のid達を返す
  vi pathe(int a, int b) {
#ifdef _DEBUG
    static bool was = 0;
    if (!was)
      message += "can't edges[id]. must edge(id)\n";
    was = 1;
#endif
    if (sz(par_id_) == 0) {
      ids_.resize(n);
      par_id_.resize(n);
      rep(i, 0, sz(edges), 2) {
        ids_[edges[i].f].emplace_back(i >> 1);
        ids_[edges[i].t].emplace_back(i >> 1);
      }
      if (never)
        precalc(); /*par_を呼ぶため*/
      rep(i, n) {
        int pa = par_[i];

        forg(gi, g[i]) {
          if (t == pa) {
            par_id_[i] = ids_[i][gi];
          }
        }
      }
    }
    int u = lca(a, b);
    vi res;
    if (a != u) {
      do {
        res.emplace_back(par_id_[a]);
        a = par_[a];
      } while (a != u);
    }
    vi rev;
    if (b != u) {
      do {
        rev.emplace_back(par_id_[b]);
        b = par_[b];
      } while (b != u);
    }
    rer(i, sz(rev) - 1) { res.emplace_back(rev[i]); }
    return res;
  }
  /*O(N) hldを使わず木を普通にたどる liteの意*/
  void for_each_l(int u, int v, function<void(int)> fnode) {
    int r = lca(u, v);
    while (u != r) {
      fnode(u);
      u = par_[u];
    }
    fnode(r);
    vi a;
    while (v != r) {
      a.push_back(v);
      v = par_[v];
    }
    while (sz(a)) {
      fnode(a.back());
      a.pop_back();
    }
  }
  void for_each_edge_l(int u, int v, function<void(edge_<int> &)> fedge) {
    int r = lca(u, v);
    while (u != r) {
      forg(gi, g[u]) {
        if (t == par_[u]) {
          fedge(g[u][gi]);
          u = par_[u];
          break;
        }
      }
    }
    vector<edge_<int>> qs;
    while (v != r) {
      forg(gi, g[v]) {
        if (t == par_[v]) {
          qs.push_back(g[v][gi]);
          v = par_[v];
          break;
        }
      }
    }
    while (sz(qs)) {
      fedge(qs.back());
      qs.pop_back();
    }
  }
  // Fは半開 (u,v)は木の頂点
  // 中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう
  void for_each_ /*[l,r)*/ (int u, int v, const function<void(int, int)> &f) {
    if (never_hld)
      hld_build();
    while (1) {
      if (vid[u] > vid[v])
        swap(u, v);
      int l = max(vid[head[v]], vid[u]);
      int r = vid[v] + 1;
      f(l, r);
      if (head[u] != head[v])
        v = par_[head[v]];
      else
        break;
    }
  }
  void for_each_edge /*[l,r) O(log(N)) 辺を頂点として扱っている
                        上と同じ感じで使える*/
      (int u, int v, const function<void(int, int)> &f) {
    if (never_hld)
      hld_build();
    while (1) {
      if (vid[u] > vid[v])
        swap(u, v);
      if (head[u] != head[v]) {
        int l = vid[head[v]];
        int r = vid[v] + 1;
        f(l, r);
        v = par_[head[v]];
      } else {
        if (u != v) {
          int l = vid[u] + 1;
          int r = vid[v] + 1;
          f(l, r);
        }
        break;
      }
    }
  }
  int bel(int v) { /*hld内での頂点番号を返す*/
    if (never_hld)
      hld_build();
    return vid[v];
  }
  // 下の頂点に辺のクエリを持たせている
  int bel(
      int f,
      int t) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
    if (never_hld)
      hld_build();
    return depth[f] > depth[t] ? vid[f] : vid[t];
  }
  int bel(
      edge_<T> &
          e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
    if (never_hld)
      hld_build();
    return depth[e.f] > depth[e.t] ? vid[e.f] : vid[e.t];
  }
  template <class... U> int operator()(U... args) { return bel(args...); }
  // path l -> r += v
  template <class S> void seg_add(S &seg, int lhei, int rhei, int v) {
    for_each_(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });
  }
  template <class S> void seg_update(S &seg, int lhei, int rhei, int v) {
    for_each_(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });
  }
  template <class S> T seg_get(S &seg, int lhei, int rhei) {
    T res = seg.e;
    for_each_(lhei, rhei,
              [&](int l, int r) { res = seg.f(res, seg.get(l, r)); });
    return res;
  }
  template <class S> void seg_add_edge(S &seg, int lhei, int rhei, int v) {
    for_each_edge(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });
  }
  template <class S> void seg_update_edge(S &seg, int lhei, int rhei, int v) {
    for_each_edge(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });
  }
  template <class S> T seg_get_edge(S &seg, int lhei, int rhei) {
    T res = seg.e;
    for_each_edge(lhei, rhei,
                  [&](int l, int r) { res = seg.f(res, seg.get(l, r)); });
    return res;
  }
  // 単体   edgeは上で処理できる
  template <class S> void seg_add(S &seg, int i, int v) { seg.add(bel(i), v); }
  template <class S> void seg_update(S &seg, int i, int v) {
    seg.update(bel(i), v);
  }
  template <class S> T seg_get(S &seg, int i) { return seg[i]; }
  template <class S> void seg_del(S &seg, int i) { seg.del(bel(i)); }

  // 部分木iに対するクエリ
  template <class S> void seg_add_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    seg.add(subl[i], subr[i], v);
  }
  template <class S> void seg_update_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    seg.update(subl[i], subr[i], v);
  }
  template <class S> T seg_get_sub(S &seg, int i, int v) {
    if (never_hld)
      hld_build();
    return seg.get(subl[i], subr[i], v);
  }
  template <class S> void seg_add_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    seg.add(subl[i] + 1, subr[i], v);
  }
  template <class S> void seg_update_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    seg.update(subl[i] + 1, subr[i], v);
  }
  template <class S> T seg_get_sub_edge(S &seg, int i, int v) {
    if (never_hld)
      hld_build(); /*iの上の辺が数えられてしまうため、i+1から*/
    return seg.get(subl[i] + 1, subr[i], v);
  }
};
// 辺が多いのでedgesを持たない
// cost oo, ox, xo, xx 渡す
template <class T = int> class grid_k6 : public undigraph<T> {
  vi costs;

public:
  using undigraph<T>::g;
  using undigraph<T>::n;
  using undigraph<T>::edges;
  int H, W;
  vector<vector<char>> ba;
  char wall;

  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("grid_k6 add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    g[t].emplace_back(t, f, c);
    // undigraphと違い、edgesを持たない
  }
  int getid(int h, int w) {
    assert(ins(h, w, H, W));
    return W * h + w;
  }
  int getid(P p) { return getid(p.first, p.second); }
  P get2(int id) { return mp(id / W, id % W); }
  P operator()(int id) { return get2(id); }
  int operator()(int h, int w) { return getid(h, w); }
  int operator()(P p) { return getid(p); }
  // 辺は無い
  grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {}
  grid_k6(vector<vector<char>> ba, char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
    rep(h, H) {
      rep(w, W) {
        if (ba[h][w] == wall)
          con;
        int f = getid(h, w);
        if (w + 1 < W && ba[h][w + 1] != wall) {
          add(f, getid(h, w + 1));
        }
        if (h + 1 < H && ba[h + 1][w] != wall) {
          add(f, getid(h + 1, w));
        }
      }
    }
  }
  /*o -> o, o -> x, x-> x*/
  grid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx,
          char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])),
        costs({oo, ox, xo, xx}), ba(ba), wall(wall) {
    rep(h, H) {
      rep(w, W) {
        add(h, w, h + 1, w);
        add(h, w, h - 1, w);
        add(h, w, h, w + 1);
        add(h, w, h, w - 1);
      }
    }
  }
  void add(int fh, int fw, int th, int tw) {
    if (ins(fh, fw, H, W) && ins(th, tw, H, W)) {
      int cm = 0;
      if (ba[fh][fw] == wall) {
        cm += 2;
      }
      if (ba[th][tw] == wall) {
        cm++;
      }
      int f = getid(fh, fw);
      int t = getid(th, tw);
      g[f].emplace_back(f, t, costs[cm]);
    }
  }
  void set_edges() {
    rep(i, n) fora(e, g[i]) if (e.f < e.t) edges.push_back(e);
  }
};

// 辺によりメモリを大量消費ためedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  int H, W;
  void add(int f, int t, T c = 1) {
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("digrid_k6 add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c);
    /*digraphと違いedgesを持たない*/
  }
  int getid(int h, int w) {
    if (!ins(h, w, H, W))
      return -1;
    return W * h + w;
  }
  P get2(int id) { return mp(id / W, id % W); }
  P operator()(int id) { return get2(id); }
  int operator()(int h, int w) { return getid(h, w); }
  digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {}
  digrid_k6(vector<vector<char>> ba, char wall = '#')
      : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
    rep(h, H) {
      rep(w, W) {
        if (ba[h][w] == wall)
          con;
        int f = getid(h, w);
        if (w + 1 < W && ba[h][w + 1] != wall) {
          add(f, getid(h, w + 1));
        }
        if (h + 1 < H && ba[h + 1][w] != wall) {
          add(f, getid(h + 1, w));
        }
      }
    }
  }
  void add(int fh, int fw, int th, int tw) {
    add(getid(fh, fw), getid(th, tw));
  }
  void set_edges() { rep(i, n) fora(e, g[i]) edges.push_back(e); }
};
// edgesを持たない
// dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template <class T = int> class segdi : public digraph<T> {
  int getid(int k) {
    if (k >= len * 2 - 1) {
      return k;
    } else if (k < len - 1) {
      return k + len;
    } else {
      return k - len + 1;
    }
  }
  void add(int f, int t, T c = 1) {
    f = getid(f);
    t = getid(t);
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("segdi add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/
  }
  int mid;
  int len;

public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  // 頂点が足りなくなったらresize
  segdi(int n_) : digraph<T>(1) {
    int nn = 1;
    while (nn < n_)
      nn *= 2;
    n_ = nn;
    len = n_;
    this->resize(n_ + (n_ - 1) * 2 + n_);
    mid = n_ + (n_ - 1) * 2;
    int ad = len * 2 - 1;
    rep(i, len - 1) {
      add(i, i * 2 + 1, 0);
      add(i, i * 2 + 2, 0);
      if (i * 2 + 1 >= len - 1) {
        add(i * 2 + 1, i + ad, 0);
        add(i * 2 + 2, i + ad, 0);
      } else {
        add(i * 2 + 1 + ad, i + ad, 0);
        add(i * 2 + 2 + ad, i + ad, 0);
      }
    }
  }
  void dfs(vi &list, int nl, int nr, int k, int l, int r) {
    if (r <= nl || nr <= l)
      return;
    if (l <= nl && nr <= r) {
      list += k;
    } else {
      dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r);
      dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r);
    }
  }
  void rekkyo(vi &list, int l, int r) {
    l += len - 1;
    r += len - 1;
    while (l < r) {
      if (!(l & 1)) {
        list.push_back(l);
      }
      if (!(r & 1)) {
        list.push_back(r - 1);
      }
      l >>= 1;
      r = (r - 1) >> 1;
    }
  }
  // 半開
  void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/
    int ad = 2 * len - 1;
    if (mid >= n) {
      this->resize(n + 100);
    }
    {
      int l = fl, r = fr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          if (l - len + 1 < 0)
            add(l + ad, mid, cost);
          else
            add(l, mid, cost);
        }
        if (!(r & 1)) {
          if (r - 1 - len + 1 < 0)
            add(r - 1 + ad, mid, cost);
          else
            add(r - 1, mid, cost);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    {
      int l = tl, r = tr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          add(mid, l, 0);
        }
        if (!(r & 1)) {
          add(mid, r - 1, 0);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    mid++;
  }
};
// edgesを持たない
// dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template <class T = int> class segun : public undigraph<T> {
  int getid(int k) {
    if (k >= len * 2 - 1) {
      return k;
    } else if (k < len - 1) {
      return k + len;
    } else {
      return k - len + 1;
    }
  }
  void add(int f, int t, T c = 1) {
    f = getid(f);
    t = getid(t);
    if (!(0 <= f && f < n && 0 <= t && t < n)) {
      debugline("segun add");
      deb(f, t, c);
      ole();
    }
    g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/
    g[t].emplace_back(t, f, c); /*digraphと違いedgesを持たない*/
  }
  int mid;
  int len;

public:
  using digraph<T>::g;
  using digraph<T>::n;
  using digraph<T>::edges;
  // 頂点が足りなくなったらresize
  segun(int n_) : digraph<T>(1) {
    int nn = 1;
    while (nn < n_)
      nn *= 2;
    n_ = nn;
    len = n_;
    this->resize(n_ + (n_ - 1) * 2 + n_);
    mid = n_ + (n_ - 1) * 2;
    int ad = len * 2 - 1;
    rep(i, len - 1) {
      add(i, i * 2 + 1, 0);
      add(i, i * 2 + 2, 0);
      if (i * 2 + 1 >= len - 1) {
        add(i * 2 + 1, i + ad, 0);
        add(i * 2 + 2, i + ad, 0);
      } else {
        add(i * 2 + 1 + ad, i + ad, 0);
        add(i * 2 + 2 + ad, i + ad, 0);
      }
    }
  }
  void dfs(vi &list, int nl, int nr, int k, int l, int r) {
    if (r <= nl || nr <= l)
      return;
    if (l <= nl && nr <= r) {
      list += k;
    } else {
      dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r);
      dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r);
    }
  }
  void rekkyo(vi &list, int l, int r) {
    l += len - 1;
    r += len - 1;
    while (l < r) {
      if (!(l & 1)) {
        list.push_back(l);
      }
      if (!(r & 1)) {
        list.push_back(r - 1);
      }
      l >>= 1;
      r = (r - 1) >> 1;
    }
  }
  // 半開
  void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/
    int ad = 2 * len - 1;
    if (mid >= n) {
      this->resize(n + 100);
    }
    {
      int l = fl, r = fr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          if (l - len + 1 < 0)
            add(l + ad, mid, cost);
          else
            add(l, mid, cost);
        }
        if (!(r & 1)) {
          if (r - 1 - len + 1 < 0)
            add(r - 1 + ad, mid, cost);
          else
            add(r - 1, mid, cost);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    {
      int l = tl, r = tr;
      l += len - 1;
      r += len - 1;
      while (l < r) {
        if (!(l & 1)) {
          add(mid, l, 0);
        }
        if (!(r & 1)) {
          add(mid, r - 1, 0);
        }
        l >>= 1;
        r = (r - 1) >> 1;
      }
    }
    mid++;
  }
};
#define getid_2(h, w) (h * W + w)
#define getid_1(p) (p.first * W + p.second)
#define o_getid(a, b, name, ...) name
#define getid(...) o_getid(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)

#define unionfind unionfind_graph
struct unionfind {
  vector<ll> par;
  vector<ll> siz;
  vector<ll> es;
  ll n, trees; // 連結グループの数(親の種類)
  unionfind(ll n) : n(n), trees(n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
  }
  template <class T> unionfind(graph<T> &g) : n(g.n), trees(g.n) {
    par.resize(n);
    siz.resize(n);
    es.resize(n);
    for (ll i = 0; i < n; i++) {
      par[i] = i;
      siz[i] = 1;
    }
    add(g);
  }
  ll root(ll x) {
    if (par[x] == x) {
      return x;
    } else {
      return par[x] = root(par[x]);
    }
  }
  ll operator()(ll x) { return root(x); }
  bool unite(ll x, ll y) {
    x = root(x);
    y = root(y);
    es[x]++;
    if (x == y)
      return false;
    if (siz[x] > siz[y])
      swap(x, y);
    trees--;
    par[x] = y;
    siz[y] += siz[x];
    es[y] += es[x];
    return true;
  }
  template <class T> void add(graph<T> &g) {
    fora(e, g.edges) { unite(e.f, e.t); }
  }
  template <class T> void unite(graph<T> &g) { add(g); }
  bool same(ll x, ll y) { return root(x) == root(y); }
  ll size(ll x) { return siz[root(x)]; }
  ll esize(ll x) { return es[root(x)]; }
  vi sizes() {
    vi cou(n);
    vi ret;
    ret.reserve(n);
    rep(i, n) { cou[root(i)]++; }
    rep(i, n) {
      if (cou[i])
        ret.push_back(cou[i]);
    }
    return ret;
  }
  // つながりを無向グラフと見なし、xが閉路に含まれるか判定
  bool close(ll x) { return esize(x) >= size(x); }
  vector<vi> sets() {
    vi ind(n, -1);
    ll i = 0;
    vvi(res, trees);
    rep(j, n) {
      ll r = root(j);
      if (ind[r] == -1)
        ind[r] = i++;
      res[ind[r]].push_back(j);
    }
    rep(i, trees) {
      ll r = root(res[i][0]);
      if (res[i][0] == r)
        continue;
      rep(j, 1, sz(res[i])) {
        if (res[i][j] == r) {
          swap(res[i][0], res[i][j]);
          break;
        }
      }
    }
    return res;
  }
}; //@formatter:off

//@出力
template <class T> ostream &operator<<(ostream &os, digraph<T> &g) {
  os << endl << g.n << " " << sz(g.edges) << endl;
  fore(gi, g.edges) { os << f << " " << t << " " << c << endl; }
  return os;
}
template <class T> ostream &operator<<(ostream &os, undigraph<T> &g) {
  os << endl << g.n << " " << sz(g.edges) / 2 << endl;
  fore(gi, g.edges) {
    if (f < t)
      os << f << " " << t << " " << c << endl;
  }
  return os;
}

//@判定
template <class T> bool nibu(graph<T> &g) {
  int size = 0;
  rep(i, g.n) size += sz(g.g[i]);
  if (size == 0)
    return true;
  unionfind uf(g.n * 2);
  rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
      uf.unite(e.f + g.n, e.t);
  rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
  return true;
}
// 頂点ではなく辺の数に依存した計算量 O(E)
template <class T> bool nibu_sub(graph<T> &g) {
  umapi col;         /*0なら無色 */
  queue<int> q;      /*色は01か11 */
  fora(e, g.edegs) { /*fとtの色を持つか否かは同じ*/
    if (col[e.f] == 0)
      q.push(e.f);
    while (!q.empty()) {
      int f = q.front();
      q.pop();
      int fc = col[f];
      forg(gi, g[f]) {
        int &tc = col[t]; /*fcには色がある*/
        if (fc == tc)
          return false; /*違う色*/
        if (tc)
          continue; /*無色*/
        tc = fc ^ 2;
        q.push(tc);
      }
    }
  }
  return true;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
  vp cg;
  if (!nibu(g)) {
    debugline("nibu");
    ole();
  }
  int n = g.size();
  vb was(n);
  queue<P> q;
  rep(i, n) {
    if (was[i])
      continue;
    q.push(mp(i, 1));
    was[i] = 1;
    int red = 0;
    int coun = 0;
    while (q.size()) {
      int now = q.front().fi;
      int col = q.front().se;
      red += col;
      coun++;
      q.pop();
      forg(gi, g[now]) {
        if (was[t])
          continue;
        q.push(mp(t, col ^ 1));
        was[t] = 1;
      }
    }
    cg.push_back(mp(red, coun - red));
  }
  return cg;
}
// 連結グラフが与えられる 閉路があるか
template <class T> bool close(undigraph<T> &g) {
  int n = 0;
  int e = 0;
  rep(i, g.n) {
    if (sz(g[i]))
      n++;
    forg(gi, g[i]) { e++; }
  }
  return (e >> 1) >= n;
}
template <class T> bool close(undigraph<T> &g, int v) {
  unionfind uf(g.n);
  rep(i, g.n) {
    forg(gi, g[i]) {
      if (f < t)
        break;
      if (f == t && f == v)
        return true;
      if (uf.same(f, v) && uf.same(t, v))
        return true;
      uf.unite(f, t);
    }
  }
  return false;
}
template <class T> bool close(digraph<T> &g) {
  vi res;
  return topo(res, g);
}

//@変形
// 条件(f!=0等 f,t,cが使える)を満たすsubgraphをg2に代入
#define sub_di(g, g2, zhouken)                                                 \
  {                                                                            \
    g2.resize(g.n);                                                            \
    fore(gi, g.edges) {                                                        \
      if (zhouken) {                                                           \
        g2.add(f, t, c);                                                       \
      }                                                                        \
    }                                                                          \
  }
#define sub_un(g, g2, zhouken)                                                 \
  {                                                                            \
    g2.resize(g.n);                                                            \
    fore(gi, g.edges) {                                                        \
      bool ok = zhouken; /*片方がアウトなら駄目という扱い*/     \
      swap(f, t);                                                              \
      ok &= zhouken;                                                           \
      if (ok && f < t) {                                                       \
        g2.add(f, t, c);                                                       \
      }                                                                        \
    }                                                                          \
  }
#define sub_tree sub_un
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
  int n = g.g.size();
  vi nyu(n);
  rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
  queue<int> st;
  rep(i, n) if (nyu[i] == 0) st.push(i);
  while (st.size()) {
    int v = st.front();
    st.pop();
    res.push_back(v);
    fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
  }
  return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
  int n = g.g.size();
  vi nyu(n);
  rep(i, n) for (auto &&e : g[i]) nyu[e.t]++; /*小さい順*/
  priority_queue<int, vector<int>, greater<int>> q;
  rep(i, n) if (nyu[i] == 0) q.push(i);
  while (q.size()) {
    int i = q.top();
    q.pop();
    res.push_back(i);
    fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
  }
  return res.size() == n;
}
template <class T> digraph<T> rev(digraph<T> &g) {
  digraph<T> r(g.n);
  rep(i, g.n) {
    forg(gi, g[i]) { r.add(t, f, c); }
  }
  return r;
}
// lc,rcは子を持つ中で一番左、右
//(g,ind,l,r)
template <class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r) {
  if (sz(ind)) {
    cerr << "ind must be empty" << endl;
    exit(0);
  }
  int N = sz(g);
  ind.resize(N);
  l.resize(N, inf);
  r.resize(N, -1);
  tree<T> h(N);
  queue<P> q;
  q.emplace(-1, 0);
  int c = 0;
  while (sz(q)) {
    int p = q.front().first;
    int i = q.front().second;
    q.pop();
    ind[i] = c;
    if (~p)
      chmi(l[ind[p]], c);
    if (~p)
      chma(r[ind[p]], c);
    c++;
    forg(gi, g[i]) {
      if (t != p)
        q.emplace(i, t);
    }
  }
  fora(e, g.edges) {
    if (e.f < e.t) {
      h.add(ind[e.f], ind[e.t], e.c);
    }
  }
  rep(i, N) {
    if (l[i] == inf)
      l[i] = -1;
  }
  return h;
}
// lc,rcは子を持つ中で一番左、右
//  たとえばl[lc[x]は2段下の最左
//(g,ind,l,r,lc,rc)
template <class T>
tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r, vi &lc, vi &rc) {
  if (sz(ind)) {
    cerr << "ind must be empty" << endl;
    exit(0);
  }
  int N = sz(g);
  ind.resize(N);
  l.resize(N, inf);
  lc.resize(N, inf);
  r.resize(N, -1);
  rc.resize(N, -1);
  tree<T> h(N);
  queue<P> q;
  q.emplace(-1, 0);
  int c = 0;
  while (sz(q)) {
    int p = q.front().first;
    int i = q.front().second;
    q.pop();
    ind[i] = c;
    if (~p) {
      chmi(l[ind[p]], c);
      chma(r[ind[p]], c);
      if (sz(g[i]) > 1) {
        chmi(lc[ind[p]], c);
        chma(rc[ind[p]], c);
      }
    }
    c++;
    forg(gi, g[i]) {
      if (t != p)
        q.emplace(i, t);
    }
  }
  fora(e, g.edges) {
    if (e.f < e.t) {
      h.add(ind[e.f], ind[e.t], e.c);
    }
  }
  rep(i, N) {
    if (l[i] == inf)
      l[i] = -1;
    if (lc[i] == inf)
      lc[i] = -1;
  }
  return h;
}

//@集計
template <class T> vi indegree(graph<T> &g) {
  vi ret(g.size());
  rep(i, g.size()) {
    forg(gi, g[i]) { ret[t]++; }
  }
  return ret;
}
template <class T> vi outdegree(graph<T> &g) {
  vi ret(g.size());
  rep(i, g.size()) { ret[i] = g[i].size(); }
  return ret;
}
#define kansetu articulation
// private
/*private*/ P farthest____(tree<> &E, int cur, int pre, int d, vi &D) {
  D[cur] = d;
  P r = {d, cur};
  forg(gi, E[cur]) if (t != pre) {
    P v = farthest____(E, t, cur, d + 1, D);
    r = max(r, v);
  }
  return r;
}
// dagでなければ-1を返す
int diameter(digraph<> &g) {
  vi per;
  if (!topo(per, g))
    return -1;
  int n = g.n;
  vi dp(n, 1);
  fora(v, per) {
    forg(gi, g[v]) { chma(dp[t], dp[f] + 1); }
  }
  return max(dp);
}
// iから最も離れた距離
vi diameters(tree<> &E) { /* diameter,center*/
  vi D[3];
  D[0].resize(E.size());
  D[1].resize(E.size());
  auto v1 = farthest____(E, 0, 0, 0, D[0]);
  auto v2 = farthest____(E, v1.second, v1.second, 0, D[0]);
  farthest____(E, v2.second, v2.second, 0, D[1]);
  int i;
  rep(i, D[0].size()) D[2].push_back(max(D[0][i], D[1][i]));
  return D[2];
}
// iに対応するjと距離
vp diameters_p(tree<> &E) { /* diameter,center*/
  vector<int> D[3];
  D[0].resize(E.size());
  D[1].resize(E.size());
  auto v1 = farthest____(E, 0, 0, 0, D[0]);
  auto v2 = farthest____(E, v1.second, v1.second, 0, D[0]);
  farthest____(E, v2.second, v2.second, 0, D[1]);
  int i;
  vp res(E.size());
  rep(i, D[0].size()) {
    if (D[0][i] > D[1][i])
      res[i] = mp(v1.second, D[0][i]);
    else
      res[i] = mp(v2.second, D[1][i]);
  }
  return res;
}
int diameter(tree<> &E) {
  vi d = diameters(E);
  return max(d);
}
// 最も離れた二点を返す
P diameter_p(tree<> &E) {
  auto d = diameters_p(E);
  int dis = -1;
  int l = -1, r = -1;
  rep(i, sz(d)) {
    if (chma(dis, d[i].se)) {
      l = i;
      r = d[i].fi;
    }
  }
  return mp(l, r);
}
//@列挙 取得
// 閉路がある時linfを返す
template <class T> int longest_path(digraph<T> &g) {
  vi top;
  if (!topo(top, g)) {
    return linf;
  }
  int n = sz(top);
  vi dp(n, 0);
  for (auto &&i : top) {
    forg(gi, g[i]) { chma(dp[t], dp[i] + 1); }
  }
  return max(dp);
}
template <class T> vi longest_path_v(digraph<T> &g) {
  vi top;
  if (!topo(top, g)) {
    return vi();
  }
  int n = sz(top);
  vi dp(n, 0);
  vi pre(n, -1);
  for (auto &&i : top) {
    forg(gi, g[i]) {
      if (chma(dp[t], dp[i] + 1)) {
        pre[t] = i;
      }
    }
  }
  int s = std::max_element(dp.begin(), dp.end()) - dp.begin();
  vi path;
  while (s != -1) {
    path.push_back(s);
    s = pre[s];
  }
  std::reverse(path.begin(), path.end());
  return path;
}
// 橋を列挙する (取り除くと連結でなくなる辺)
template <class T> vp bridge(graph<T> &G) {
  static bool was;
  vp brid;
  vi articulation;
  vi ord(G.n), low(G.n);
  vb vis(G.n);
  function<void(int, int, int)> dfs = [&](int v, int p, int k) {
    vis[v] = true;
    ord[v] = k++;
    low[v] = ord[v];
    bool isArticulation = false;
    int ct = 0;
    for (int i = 0; i < G[v].size(); i++) {
      if (!vis[G[v][i].t]) {
        ct++;
        dfs(G[v][i].t, v, k);
        low[v] = min(low[v], low[G[v][i].t]);
        if (~p && ord[v] <= low[G[v][i].t])
          isArticulation = true;
        if (ord[v] < low[G[v][i].t])
          brid.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
      } else if (G[v][i].t != p) {
        low[v] = min(low[v], ord[G[v][i].t]);
      }
    }
    if (p == -1 && ct > 1)
      isArticulation = true;
    if (isArticulation)
      articulation.push_back(v);
  };
  int k = 0;
  rep(i, G.n) {
    if (!vis[i])
      dfs(i, -1, k);
  }
  sort(brid.begin(), brid.end());
  return brid;
}
// 間接点を列挙する (取り除くと連結でなくなる点)
template <class T> vi articulation(undigraph<T> &G) {
  static bool was;
  vp bridge;
  vi arti;
  vi ord(G.n), low(G.n);
  vb vis(G.n);
  function<void(int, int, int)> dfs = [&](int v, int p, int k) {
    vis[v] = true;
    ord[v] = k++;
    low[v] = ord[v];
    bool isArticulation = false;
    int ct = 0;
    for (int i = 0; i < G[v].size(); i++) {
      if (!vis[G[v][i].t]) {
        ct++;
        dfs(G[v][i].t, v, k);
        low[v] = min(low[v], low[G[v][i].t]);
        if (~p && ord[v] <= low[G[v][i].t])
          isArticulation = true;
        if (ord[v] < low[G[v][i].t])
          bridge.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
      } else if (G[v][i].t != p) {
        low[v] = min(low[v], ord[G[v][i].t]);
      }
    }
    if (p == -1 && ct > 1)
      isArticulation = true;
    if (isArticulation)
      arti.push_back(v);
  };
  int k = 0;
  rep(i, G.n) {
    if (!vis[i])
      dfs(i, -1, k);
  }
  sort(arti.begin(), arti.end());
  return arti;
}
// 閉路パスを一つ返す
vi close_path(digraph<> &g) {
  int n = g.n;
  vi state(n);
  vi path;
  rep(i, n) if (!state[i]) {
    if (fix([&](auto dfs, int v) -> bool {
          if (state[v]) {
            if (state[v] == 1) {
              path.erase(path.begin(), find(path.begin(), path.end(), v));
              return true;
            }
            return false;
          }
          path.push_back(v);
          state[v] = 1;
          forg(gi, g[v]) {
            if (dfs(t))
              return true;
          }
          state[v] = -1;
          path.pop_back();
          return false;
        })(i)) {
      return path;
    }
  }
  return vi();
}
vi close_path_min(digraph<> &g) {
  int n = g.n;
  vvi(dis, n);
  rep(i, n) dis[i] = dijkstra(g, i, linf);
  int mind = linf;
  int f = 0, t = 0;
  rep(i, n) {
    rep(j, n) {
      if (i == j)
        continue;
      if (chmi(mind, dis[i][j] + dis[j][i])) {
        f = i;
        t = j;
      }
    }
  }
  vi path;
  auto add = [&](int f, int t) {
    int now = f;
    while (now != t) {
      rep(i, n) {
        if (dis[now][i] == 1 && dis[f][i] + dis[i][t] == dis[f][t]) {
          path.push_back(i);
          now = i;
          break;
        }
      }
    }
  };
  add(f, t);
  add(t, f);
  return path;
}
// iを含む最短閉路 https://atcoder.jp/contests/abc022/tasks/abc022_c
/*閉路が1つしかない場合、その閉路に含まれる頂点を1としたvectorを返す*/;
template <class T> vi get_close1(digraph<T> &g) {
  int n = g.n;
  queue<int> q;
  vi d = outdegree(g);
  vi res(n, 1);
  rep(i, n) {
    if (d[i] == 0) {
      q += i;
      res[i] = 0;
    }
  }
  auto rg = rev(g);
  while (q.size()) {
    auto now = q.front();
    q.pop();
    forg(gi, rg[now]) {
      if (--d[t] == 0) {
        q += t;
        res[t] = 0;
      }
    }
  }
  return res;
}

//@アルゴリズム
template <class T> int krus(undigraph<T> &g) {
  int res = 0;
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e.c;
    }
  }
  return res;
}
template <class T> vector<edge_<T>> krus_ed(undigraph<T> &g) {
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  vector<edge_<T>> res;
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res.push_back(e);
    }
  }
  return res;
}
template <class T> tree<T> krus_tr(undigraph<T> &g) {
  tree<T> res(g.n);
  unionfind uf(g.n);
  if (sz(g.edges) == 0)
    g.set_edges();
  int i = 0;
  auto E = g.edges;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res.add(e.f, e.t);
    }
  }
  return res;
}
template <class T> int krus(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  int res = 0;
  unionfind uf(n);
  auto E = g;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e.c;
    }
  }
  return res;
}
template <class T> vector<edge_<T>> krus_ed(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  vector<edge_<T>> res;
  unionfind uf(n);
  auto E = g;
  sort(E);
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += e;
    }
  }
  return res;
};
template <class T> vi krus_i(vector<edge_<T>> &g) {
  int n = 0;
  fora(e, g) { chma(n, max(e.f, e.t) + 1); };
  vi res;
  unionfind uf(n);
  auto E = g;
  sort(E);
  int i = 0;
  fora(e, E) {
    if (uf.unite(e.f, e.t)) {
      res += i;
    }
    i++;
  }
  return res;
}
//@実験
digraph<> rang_di(int n, int m, bool zibun = 0, bool taju = 0) {
  umapp was;
  digraph<> g(n);
  was[mp(-1, -2)] = 1;
  while (m) {
    int f = -1, t = -2;
    while (f < 0 || (!taju && was[mp(f, t)])) {
      f = rand(0, n - 1);
      t = rand(0, n - 1);
      if (!zibun && f == t)
        f = -1;
    }
    g.add(f, t);
    was[mp(f, t)] = 1;
    m--;
  }
  return g;
}
digraph<> perfect_di(int n, bool zibun = 0) {
  digraph<> g(n);
  rep(i, n) {
    rep(j, n) {
      if (!zibun && i == j)
        con;
      g.add(i, j);
    }
  }
  return g;
}
undigraph<> rang_un(int n, int m, bool zibun = 0, bool taju = 0) {
  umapp was;
  undigraph<> g(n);
  was[mp(-1, -2)] = 1;
  while (m) {
    int f = -1, t = -2;
    while (f < 0 || (!taju && was[mp(min(f, t), max(f, t))])) {
      f = rand(0, n - 1);
      t = rand(0, n - 1);
      if (!zibun && f == t)
        f = -1;
    }
    g.add(f, t);
    was[mp(min(f, t), max(f, t))] = 1;
    m--;
  }
  return g;
}
undigraph<> perfect_un(int n, bool zibun = 0) {
  undigraph<> g(n);
  rep(i, n) {
    rep(j, i, n) {
      if (!zibun && i == j)
        con;
      g.add(i, j);
    }
  }
  return g;
}
/*頂点数がkの木を一つ返す サイズが0の木が帰ったら終了*/
tree<int> next_tree(int k) {
  assert(2 <= k && k < 11);
  static str name;
  static ifstream ina;
  static int rem;
  static vp edges;
  static int pk = -1; /*前回見たk*/
  if (pk != k) {
    if (~pk)
      ina.close();
    edges.clear();
    pk = k;
    name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\trees_sizek\\nazeka6.txt"
                    : "C:\\Users\\kaout\\Desktop\\trees_sizek\\tree_size" +
                          tos(k) + ".txt";
    ina = ifstream(name);
    rem = pow(k, k - 2); /*Cayleyの定理*/
    rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
    pk = k;
  }
  tree<int> g(k);
  if (rem == 0) {
    g.resize(0);
    return g;
  }
  int m;
  ina >> m;
  while (m) {
    int lb = lbit(m);
    int id = log2(lb);
    g.add(edges[id].first, edges[id].second);
    m ^= lb;
  }
  rem--;
  return g;
}
undigraph<int> next_undi(int k) {
  assert(2 <= k && k < 9);
  static str name;
  static ifstream ina;
  static int rem;
  static vp edges;
  static vi lims = {-1, -1, 1, 4, 38, 728, 26704, 1866256};
  static int pk = -1; /*前回見たk*/
  if (pk != k) {
    if (~pk)
      ina.close();
    edges.clear();
    pk = k;
    name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\undi_sizek\\roku.txt"
                    : "C:\\Users\\kaout\\Desktop\\undi_sizek\\undi_size" +
                          tos(k) + ".txt";
    ina = ifstream(name);
    rem = lims[k];
    rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
    pk = k;
  }
  undigraph<int> g(k);
  if (rem == 0) {
    g.resize(0);
    return g;
  }
  int m;
  ina >> m;
  while (m) {
    int lb = lbit(m);
    int id = log2(lb);
    g.add(edges[id].first, edges[id].second);
    m ^= lb;
  }
  rem--;
  return g;
}
vector<tree<int>> trees(int k) {
  vector<tree<int>> res;
  while (1) {
    tree<int> g = next_tree(k);
    if (sz(g) == 0)
      break;
    res.push_back(g);
  }
  return res;
}
vector<undigraph<int>> undis(int k) {
  vector<undigraph<int>> res;
  while (1) {
    undigraph<int> g = next_undi(k);
    if (sz(g) == 0)
      break;
    res.push_back(g);
  }
  return res;
}
template <class T> vector<vector<int>> table(graph<T> &g, int init_value) {
  vvi(res, g.n, g.n, init_value);
  rep(i, g.n) {
    forg(gi, g[i]) { res[i][t] = c; }
  }
  return res;
}
// type,idが使いたい場合はgraty
/*@formatter:on*/

namespace mint_china { /*@formatter:off*/
ll minv(ll a, ll m) {
  ll u = 0, v = 1;
  while (a != 0) {
    ll t = m / a;
    m -= t * a;
    swap(a, m);
    u -= t * v;
    swap(u, v);
  }
  assert(m == 1);
  return u;
}
ll garner(const vector<ll> &x, vector<ll> mods, ll mod = 0) {
  mods.emplace_back(mod);
  int n = sz(x);
  vector<ll> coeff; /* coeff[i]v_i*/
  vector<ll> constants;
  if (mod) {
    coeff.assign(n + 1, 1);
    constants.assign(n + 1, 0);
  } else {
    coeff.assign(n, 1);
    constants.assign(n, 0);
  }
  int nj = n + !!mod;
  for (size_t i = 0; i < n; i++) {
    ll v = (x[i] - constants[i]) * minv(coeff[i], mods[i]) % mods[i];
    if (v < 0)
      v += mods[i];
    for (size_t j = i + 1; j < nj; j++) {
      constants[j] = (constants[j] + coeff[j] * v) % mods[j];
      coeff[j] = (coeff[j] * mods[i]) % mods[j];
    }
  }
  return constants.back();
}
bool to_disjoint(vi &vs, vi &ms) {
  vector<int> primes;
  int maxm = *max_element(ms.begin(), ms.end());
  int lim = sqrt(maxm);
  vb p(lim + 1);
  for (int i = 2; i <= lim; i++) {
    if (p[i])
      continue;
    primes.eb(i);
    for (int j = i * i; j <= lim; j += i)
      p[j] = true;
  }
  for (int m : ms) {
    for (int p : primes)
      while (m % p == 0)
        m /= p;
    if (m != 1)
      primes.emplace_back(m);
  }
  int n = sz(ms);
  for (int p : primes) {
    vp ps;
    for (int i = 0; i < n; i++) {
      if (ms[i] % p == 0) {
        int lg = 0;
        while (ms[i] % p == 0)
          ms[i] /= p, lg++;
        ps.eb(lg, i);
      }
    }
    if (ps.size() < 1)
      continue;
    sort(ps);
    int base = vs[ps.back().second];
    for (auto d : ps) {
      if ((vs[d.second] - base) % p)
        return false;
      if (d.second == ps.back().second)
        for (int i = 0; i < d.first; i++)
          ms[d.second] *= p;
    }
  }
  return true;
}
int extGCD(int a, int b, int &x0, int &x1) {
  x0 = 1, x1 = 0;
  int y0 = 0, y1 = 1;
  while (b != 0) {
    int q = a / b;
    int r = a % b;
    int x2 = x0 - q * x1;
    int y2 = y0 - q * y1;
    a = b;
    b = r;
    x0 = x1;
    x1 = x2;
    y0 = y1;
    y1 = y2;
  }
  return a;
}
// 答えを x ≡ r (mod. M) として、{r, M} をリターン, 存在しない場合は {0, -1}
// をリターン
P ChineseRem(const vi &b, const vi &m) {
  int r = 0, M = 1;
  for (int i = 0; i < (int)b.size(); ++i) {
    int p, q;
    int d = extGCD(M, m[i], p, q); /* p is inv of M/d (mod. m[i]/d)*/
    if ((b[i] - r) % d != 0)
      return make_pair(0, -1);
    long long tmp = (b[i] - r) / d * p % (m[i] / d);
    r += M * tmp;
    M *= m[i] / d;
  }
  return make_pair(mod(r, M), M);
}
int china_m_r_mod_dj(vi &ms, vi &rs, int mod = 0,
                     int disjoint = -3) { /*中国余剰定理*/
  if (mod == 0) {
    bool exist_non_zero = false;
    for (int i = 0; i < sz(rs); ++i) {
      if (rs[i])
        exist_non_zero = true;
    }
    P res = ChineseRem(rs, ms);
    if (res.second == -1)
      return -1;
    else if (exist_non_zero)
      return res.first;
    else
      return res.second;
  } else {
    if (disjoint != -3 && !to_disjoint(rs, ms))
      return -1;
    int allzero = 1;
    ll ans = 1;
    int n = sz(ms);
    rep(i, n) {
      rs[i] = rs[i] % ms[i];
      if (rs[i] != 0)
        allzero = 0;
    }
    if (allzero) {
      if (mod)
        rep(i, n) ans = ans * ms[i] % mod;
      else
        rep(i, n) ans = ans * ms[i];
      return ans;
    }
    return garner(rs, ms, mod);
  }
}
// 基本chinaを使えばいい 答えが無ければ-
// m r
constexpr int MOD = 1000000007;
constexpr int MOE = 1000000009;
/*@formatter:on*/
struct mint {
  int X[2];
  mint() { X[0] = X[1] = 0; }
  mint(int a) {
    if (a < 0)
      X[0] = (a % MOD) + MOD, X[1] = (a % MOE) + MOE;
    else
      X[0] = a % MOD, X[1] = a % MOE;
  }
  mint &operator+=(mint that) {
    X[0] = (X[0] + that.X[0]) % MOD;
    X[1] = (X[1] + that.X[1]) % MOE;
    return *this;
  }
  mint &operator-=(mint that) {
    X[0] = (X[0] + MOD - that.X[0]) % MOD;
    X[1] = (X[1] + MOE - that.X[1]) % MOE;
    return *this;
  }
  mint &operator*=(mint that) {
    X[0] = (X[0] * that.X[0]) % MOD;
    X[1] = (X[1] * that.X[1]) % MOE;
    return *this;
  }
  mint &operator/=(mint that) { return *this *= that.inverse(); }
  mint operator-() {
    mint res = *this;
    if (X[0])
      res.X[0] = MOD - X[0];
    if (X[1])
      res.X[1] = MOE - X[1];
    return res;
  }
  friend ostream &operator<<(ostream &out, mint m) { return out << (int)m; }
  mint inverse() {
    mint ret;
    {
      int a = X[0], b = MOD, u = 1, v = 0;
      while (b) {
        int t = a / b;
        a -= t * b;
        u -= t * v;
        swap(a, b);
        swap(u, v);
      }
      if (u < 0)
        u = (u + MOD);
      ret.X[0] = (u);
    }
    {
      int a = X[1], b = MOE, u = 1, v = 0;
      while (b) {
        int t = a / b;
        a -= t * b;
        u -= t * v;
        swap(a, b);
        swap(u, v);
      }
      if (u < 0)
        u = (u + MOE);
      ret.X[1] = u;
    }
    return ret;
  }
  operator int() const {
    vi ms = {MOD, MOE};
    vi rs = {X[0], X[1]};
    return china_m_r_mod_dj(ms, rs);
  }
  template <class T> mint &operator+=(T that) { return operator+=((mint)that); }
  template <class T> mint &operator-=(T that) { return operator-=((mint)that); }
  template <class T> mint &operator*=(T that) { return operator*=((mint)that); }
  template <class T> mint &operator/=(T that) { return operator/=((mint)that); }
  mint operator+(mint that) { return mint(*this) += that; }
  mint operator-(mint that) { return mint(*this) -= that; }
  mint operator*(mint that) { return mint(*this) *= that; }
  mint operator/(mint that) { return mint(*this) /= that; }
  template <class T> mint operator+(T that) {
    return mint(*this) += (mint)that;
  }
  template <class T> mint operator-(T that) {
    return mint(*this) -= (mint)that;
  }
  template <class T> mint operator*(T that) {
    return mint(*this) *= (mint)that;
  }
  template <class T> mint operator/(T that) {
    return mint(*this) /= (mint)that;
  }
  //        bool operator==(mint that) const { return x == that.x && y ==
  //        that.y; }
  //        //重い
  //        bool operator==(signed that) const { return x == (mint) that; }
  //        bool operator!=(mint that) const { return !(x == that); }
  //        bool operator<(mint that) const { return (int) x < (int) that; }
  //        bool operator<=(mint that) const { return (int) x <= (int) that; }
  //        bool operator>(mint that) const { return (int) x > (int) that; }
  //        bool operator>=(mint that) const { return (int) x >= (int) that; }
};
istream &operator>>(istream &i, mint &a) {
  int v;
  i >> v;
  a = mint(v);
  return i;
}
typedef vector<mint> vm;
//    vector<mint> fac, finv;
int mint_len = 1400000; // 既に変更されていたら変えない
mint fac[1400001], finv[1400001];
struct setmod {
  setmod() {
    //            if (mint_len >= MOD - 1)mint_len = MOD - 1;
    //            if (mint_len >= MOE - 1)mint_len = MOE - 1;
    //            fac = vector<mint>(mint_len + 1);
    //            finv = vector<mint>(mint_len + 1);
    fac[0] = 1;
    rep(i, 1, mint_len + 1) { fac[i] = fac[i - 1] * i; }
    finv[mint_len] = (mint)1 / fac[mint_len];
    rer(i, mint_len, 1) { finv[i - 1] = finv[i] * i; }
  }
} setmodv;
mint com(int a, int b) {
  if (a < 0)
    return 0;
  if (b < 0 || b > a)
    return 0;
  return fac[a] * finv[a - b] * finv[b];
}
mint hom(int a, int b) { return com(a + b - 1, b); }
template <typename T, typename U> mint mpow(const T a, const U b) {
  assert(b >= 0);
  mint x = a, res = 1;
  U p = b;
  while (p > 0) {
    if (p & 1)
      (res *= x);
    x *= x;
    p >>= 1;
  }
  return res;
} /*@formatter:on*/
using PM = pair<mint, mint>;
using vm = vector<mint>;
#define vvm(...)                                                               \
  o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(mint, __VA_ARGS__)
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
} // namespace mint_china
//!!!答えが負になってはいけない
using mint = mint_china::mint;

void solve() {
  in(N);
  tree<> g(2 * k5);
  g.ing(N, N - 1);
  in(M);
  dna2d(U, V, M);
  vi in(M);
  fora(i, u, v, U, V) {       /*@formatter:off*/
    fora_init(i, u, v, U, V); /*@formatter:on*/
    auto D = g.pathe(u, v);
    in[i] = bit(D);
  }
  deb2(in);
  mint res = 0;
  rep(mas, bit(M)) {
    int use = 0;
    rep(i, M) {
      if (bget(mas, i))
        use |= in[i];
    }
    deb2(mas);
    deb2(use);
    int ziyu = N - 1;
    ziyu -= bcou(use);
    if ((bcou(mas) % 2) == 0) {
      res += powi(2, ziyu);
    } else {
      res -= powi(2, ziyu);
    }
  }
  out(res);
}

auto my(ll n, vi &a) { return 0; }

auto sister(ll n, vi &a) {
  ll ret = 0;
  return ret;
}

signed main() {
  solve();

#define arg n, a
#ifdef _DEBUG
  bool bad = 0;
  for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
    ll n = rand(1, 8);
    vi a = ranv(n, 1, 10);
    auto myres = my(arg);
    auto res = sister(arg);
    ok = myres == res;
    if (!ok) {
      out(arg);
      cerr << "AC : " << res << endl;
      cerr << "MY  : " << myres << endl;
      bad = 1;

      break;
    }
  }
  if (!bad) {
    //        cout << "完璧 : solveを書き直そう" << endl;
    //        cout << "     : そして、solve()を呼び出すのだ" << endl;
    //        cout << "     : cin>>n; na(a,n);も忘れるな" << endl;
  }
  if (sz(message)) {
    cerr << "****************************" << endl;
    cerr << message << endl;
    cerr << "****************************" << endl;
  }
#endif
  return 0;
};