Problem p03411 (C++)

Buggy submission (status: Runtime Error):
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
// 衝突対策
#define ws wszzzz
#define int long long

//@formatter:off
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;
  }
  int operator[](int i) {
    assert(i < 4);
    return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
  }
};
typedef T2<int, int, int> T;
typedef F2<int, int, int, int> F;
T mt(int a, int b, int c) { return T(a, b, c); }

//@マクロ省略系 型,構造
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define elf else if

#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 lamb(right) [&](int p) { return p right; }

// マクロ省略系 コンテナ

using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...)                                                               \
  _overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)

using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)

using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)

using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)

using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)

using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)

using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)

using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)

#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))

#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>

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<int>(__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 PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap

// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define rep1(n) for (int rep1i = 0, _lim = n; rep1i < _lim; rep1i++)
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...)                                                               \
  _overloadrep(__VA_ARGS__, repadd, repi, _rep, rep1)(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)

#define reps2(i, j, n)                                                         \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n)                                                      \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)                                             \
      for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n)                                                   \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)                                             \
      for (int k = 0; k < _lim; k++)                                           \
        for (int l = 0; l < _lim; l++)

#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...)                                                              \
  _overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)

#define repss(i, j, k, a, b, c)                                                \
  for (int i = 0; i < a; i++)                                                  \
    for (int j = 0; j < b; j++)                                                \
      for (int k = 0; k < c; k++)

#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve)                                                           \
  for (int gi = 0, _lim = ve.size(), f, t, c;                                  \
       gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve)                                                           \
  for (int gi = 0, f, t, c;                                                    \
       gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true);     \
       gi++)                                                                   \
    if (t != p)

#define form(st, l, r)                                                         \
  for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r)                                                        \
  for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)

// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};

// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
#define mp make_pair
#define pb push_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(int a) { return !(a & 1); }
constexpr bool od(int 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 まとめ
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 << endl;
  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 (int 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 (int i = 0; i < vec.size(); i++) {
    for (int j = 0; j < vec[0].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 <typename V, typename H> void resize(vector<V> &vec, const H head) {
  vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
  vec.resize(head);
  for (auto &v : vec)
    resize(v, tail...);
}
template <typename T, typename F> bool all_of(const vector<T> &v, F f) {
  return std::all_of(v.begin(), v.end(), f);
}
template <typename T, typename F> bool any_of(const vector<T> &v, F f) {
  return std::any_of(v.begin(), v.end(), f);
}
template <typename T, typename F> bool none_of(const vector<T> &v, F f) {
  return std::none_of(v.begin(), v.end(), f);
}
template <typename T, typename F> int find_if(const vector<T> &v, F f) {
  return std::find_if(v.begin(), v.end(), f) - v.begin();
}
template <typename T, typename F> int rfind_if(const vector<T> &v, F f) {
  return sz(v) - 1 - (find_if(v.rbegin(), v.rend(), f) - v.rbegin());
}
template <class T> bool contains(const string &s, const T &v) {
  return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
  return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if(const vector<T> &v, F f) {
  return find_if(v.begin(), v.end(), f) != v.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
  replace(a.begin(), a.end(), 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;
  int kn = sz(key);
  std::string::size_type Pos(a.find(key));
  int 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<int> &ve, int s, int n) {
  ve.resize(n);
  iota(all(ve), s);
}
vi iota(int s, int 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)); }
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;
}
// 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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 (int i = 0, n = a.size(); i < n; i++)
    sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
  for (int i = 0, n = a.size(); i < n; i++)
    rsort(a[i]);
}

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 V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
  for (auto &&vx : vecc)
    fill(vx, vall);
}
template <class T, class U> void fill(vector<T> &a, U val, vi &ind) {
  fora(v, ind) a[v] = val;
}
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;
}
//@汎用便利関数 入力
int in() {
  int 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 _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a)                                                                \
  int a;                                                                       \
  cin >> a
#define din2(a, b)                                                             \
  int a, b;                                                                    \
  cin >> a >> b
#define din3(a, b, c)                                                          \
  int a, b, c;                                                                 \
  cin >> a >> b >> c
#define din4(a, b, c, d)                                                       \
  int a, b, c, d;                                                              \
  cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)

#define _overloaddind(_1, _2, _3, _4, name, ...) name
#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(...)                                                              \
  _overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)

#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...)                                                               \
  _overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))

template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
template <class T> void na(vector<T> &a, int n) {
  a.resize(n);
  rep(i, n) cin >> a[i];
}
#define dna(a, n)                                                              \
  vi a(n);                                                                     \
  rep(_i, n) cin >> a[_i];
template <class T> void nao(vector<T> &a, int n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1];
}
template <class T> void nad(vector<T> &a, int n) {
  a.resize(n);
  rep(i, n) cin >> a[i], a[i]--;
}
template <class T, class U> void na2(vector<T> &a, vector<U> &b, int n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i];
}
#define dna2(a, b, n)                                                          \
  vi a(n), b(n);                                                               \
  rep(_i, n) cin >> a[_i] >> b[_i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, int n) {
  a.resize(n + 1);
  b.resize(n + 1);
  a[0] = b[0] = 0;
  rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, int 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 V>
void na3(vector<T> &a, vector<U> &b, vector<V> &c, int 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(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
template <class T, class U, class V>
void na3d(vector<T> &a, vector<U> &b, vector<V> &c, int 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(_i, n) {                                                                 \
    cin >> a[_i] >> b[_i] >> c[_i];                                            \
    a[_i]--, b[_i]--, c[_i]--;                                                 \
  }
#define nt(a, h, w)                                                            \
  resize(a, h, w);                                                             \
  rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w)                                                           \
  rs(a, h, w);                                                                 \
  rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w)                                                           \
  resize(a, h + 2, w + 2);                                                     \
  fill(a, '#');                                                                \
  rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];

// デバッグ
#define sp << " " <<

#define debugName(VariableName) #VariableName

#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__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__)

#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name

#ifdef _DEBUG
#define deb(...)                                                               \
  cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6,       \
                        _deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__)        \
       << endl
#else
#define deb(...) ;
#endif

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

// よく使うクラス、構造体
class UnionFind {
public:
  vi par, rank, sizes;
  int n, trees;
  UnionFind(int n) : n(n), trees(n) {
    par.resize(n), rank.resize(n), sizes.resize(n);
    rep(i, n) par[i] = i, sizes[i] = 1;
  }
  int root(int x) {
    if (par[x] == x)
      return x;
    else
      return par[x] = root(par[x]);
  }
  int find(int x) { return root(x); }
  void unite(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return;
    if (rank[x] < rank[y])
      swap(x, y);
    trees--;
    par[y] = x;
    sizes[x] += sizes[y];
    if (rank[x] == rank[y])
      rank[x]++;
  }
  bool same(int x, int y) { return root(x) == root(y); }
  int size(int x) { return sizes[root(x)]; }
  // 順不同 umapなので
  vec<vi> sets() {
    vec<vi> res(trees);
    umap<int, vi> map;
    rep(i, n) map[root(i)].push_back(i);
    int i = 0;
    for (auto &&p : map) {
      int r = p.fi;
      res[i].push_back(r);
      for (auto &&v : p.se) {
        if (r == v)
          continue;
        res[i].push_back(v);
      }
      i++;
    }
    return res;
  }
};

using bint = __int128;
using u32 = unsigned int;
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 = '-';
    }
    int 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 (int 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;
}

// 便利関数

// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int 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);
    }
  }
}
vi ranv(int n, int min, int max) {
  vi v(n);
  rep(i, n) v[i] = rand(min, max);
  return v;
}
str ransu(int n) {
  str s;
  rep(i, n) s += (char)rand('A', 'Z');
  return s;
}
str ransl(int n) {
  str s;
  rep(i, n) s += (char)rand('a', 'z');
  return s;
}
// 単調増加
vi ranvinc(int n, int min, int 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(int n, int min, int 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]);
  }
}
vp run_length(vi &a) {
  vp 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, int>> run_length(string &a) {
  vector<pair<char, 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;
}
template <class F> int mgr(int ok, int ng, F f) {
  if (ok < ng)
    while (ng - ok > 1) {
      int mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid;
      else
        ng = mid;
    }
  else
    while (ok - ng > 1) {
      int mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid;
      else
        ng = mid;
    }
  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 {
    rep(i, sz(a)) {
      if (a[i] < b[i]) {
        return b;
      } else if (a[i] > b[i])
        return a;
    }
  }
  return a;
}
// strを整数として比較
string smin(str &a, str b) {
  if (sz(a) < sz(b)) {
    return a;
  } else if (sz(a) > sz(b)) {
    return b;
  } else {
    rep(i, sz(a)) {
      if (a[i] < b[i]) {
        return a;
      } else if (a[i] > b[i])
        return b;
    }
  }
  return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
  rep(i, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &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 V, typename U>
T find(vector<vector<vector<V>>> &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);
}

template <typename T, typename F> int count_if(const T &v, F f) { return f(v); }
template <typename T, typename F> int count_if(const vector<T> &vec, F f) {
  int ret = 0;
  fora(v, vec) ret += count_if(v, f);
  return ret;
}

template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
  int ret = 0;
  fora(v, a) ret += count(v, k);
  return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
  int ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
int count(str a, str k) {
  int ret = 0, len = k.length();
  auto pos = a.find(k);
  while (pos != string::npos)
    pos = a.find(k, pos + len), ret++;
  return ret;
}
template <typename V> int count_od(vector<V> &a) {
  return count_if(a, [](int v) { return v & 1; });
}
template <typename V> int count_ev(vector<V> &a) {
  return count_if(a, [](int v) { return !(v & 1); });
}
#define couif count_if
// algorythm

inline 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 T> vector<T> revv(vector<T> &a) {
  vector<T> b = a;
  reverse(all(b));
  return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
                       10,
                       100,
                       1000,
                       10000,
                       100000,
                       1000000,
                       10000000,
                       100000000,
                       1000000000,
                       10000000000ll,
                       100000000000ll,
                       1000000000000ll,
                       10000000000000ll,
                       100000000000000ll,
                       1000000000000000ll,
                       10000000000000000ll,
                       100000000000000000ll,
                       1000000000000000000ll};

int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
  if (v < p10[9]) {
    if (v < p10[4]) {
      if (v < p10[2]) {
        if (v < p10[1])
          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 if (v < p10[15])
          return 15;
        else
          return 16;
      } else {
        if (v < p10[17])
          return 17;
        else
          return 18;
      }
    }
  }
}
int dsum(int v) {
  int ret = 0;
  for (; v; v /= 10)
    ret += v % 10;
  return ret;
}

struct sint {
  int v;
  sint(int v) : v(v) {}
  operator int() { return v; }
  // 下からi番目
  int operator[](int i) { return (v / p10[i]) % 10; }
  int back(int i) { return operator[](i); }
  // 上からi番目
  int top(int i) {
    int len = keta(v);
    return operator[](len - 1 - i);
  }
  // 先頭からi番目にセット
  int settop(int i, int k) {
    int len = keta(v);
    return set(len - 1 - i, k);
  }
  int set(int i, int k) {
    if (i < 0)
      return settop(abs(i) - 1, k);
    return v += p10[i] * (k - (v / p10[i]) % 10);
  }
  int add(int i, int k = 1) { return v += p10[i] * k; }
  int addtop(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
  int dec(int i, int k = 1) { return v -= p10[i] * k; }
  int dectop(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o)                                                               \
  template <class T> inline t operator o(T r) { return v o r; }
  op(int, +=);
  op(int, -=);
  op(int, *=);
  op(int, /=);
  op(int, %=);
  op(int, +);
  op(int, -);
  op(int, *);
  op(int, /);
  op(int, %);
  op(bool, ==);
  op(bool, !=);
  op(bool, <);
  op(bool, <=);
  op(bool, >);
  op(bool, >=);
#undef op
  template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
  template <class T> inline int operator<<(T r) { return v * p10[r]; }
  template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
  template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T> auto keys(T a) {
  vector<decltype((a.begin())->fi)> res;
  for (auto &&k : a)
    res.pb(k.fi);
  return res;
}
template <class T> auto values(T a) {
  vector<decltype((a.begin())->se)> res;
  for (auto &&k : a)
    res.pb(k.se);
  return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
  return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
  return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
  return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
  return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
  return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
  return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
  return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
  return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline 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> inline 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>
inline 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>
inline 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>
inline 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>
inline 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> inline 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> inline A min(A (&a)[N][O]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline 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>
inline 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>
inline 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>
inline 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) {
  T ret = 0;
  rep(i, sz(v)) ret += v[i];
  return ret;
}
template <class T> T sum(vector<vector<T>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<vector<T>>>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
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... V>
inline auto sum(vector<T> &v, U head, V... tail) {
  auto ret = sum(v[0], tail...);
  rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
  return ret;
}
void clear(PQ &q) {
  while (q.size())
    q.pop();
}
template <class T> void clear(queue<T> &q) {
  while (q.size())
    q.pop();
}
template <class T> T *negarr(int size) {
  T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
  return body + size;
}
template <class T> T *negarr2(int h, int w) {
  double **dummy1 = new double *[2 * h + 1];
  double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
  dummy1[0] = dummy2 + w;
  for (int 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 imocou(vector<T> &a, U k) {
  vector<T> ret = a;
  rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
  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> struct ruiC {
  const vector<T> rui;
  ruiC(vector<T> &ru) : rui(ru) {}
  inline T operator()(int l, int r) {
    assert(l <= r);
    return rui[r] - rui[l];
  }
  inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
  const T *rrui;
  rruic(T *ru) : rrui(ru) {}
  inline T operator()(int l, int r) {
    assert(l >= r);
    return rrui[r] - rrui[l];
  }
  inline T operator[](int i) { return rrui[i]; }
};
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(vector<T> &a) {
  vector<T> ret = ruiv(a);
  return ruiC<T>(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<int> ruic(T &a, U k) {
  vi ret = ruiv(a, k);
  return ruiC<int>(ret);
}

// xor
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> 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) {
  int 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> rruic<T> rrui(vector<T> &a) {
  int len = a.size();
  T *body = (T *)malloc((len + 1) * sizeof(T));
  T *res = body + 1;
  rer(i, len - 1) res[i - 1] = res[i] + a[i];
  return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
  int 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(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 T> void dec(vector<T> &a) {
  for (auto &u : a)
    dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class T> void minu(vector<T> &a) {
  for (auto &u : a)
    dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
void minu(string &a) {
  for (auto &u : a)
    dec(u, 1);
}
bool inside(int h, int w, int H, int W) {
  return h >= 0 && w >= 0 && h < H && w < W;
}
bool inside(int l, int v, int r) { return l <= v && v < r; }
template <class T> bool inside(vector<T> &a, int i, int j = 0) {
  return inside(0, i, sz(a)) && inside(0, j, sz(a));
}
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
  vector<T> ret = a;
  fora(v, ret) v = u(v);
  return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> 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;
}
ll goldt(ll left, ll right, function<ll(ll)> 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;
}
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;
}

constexpr bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
  m /= (ll)pow(sinsuu, keta);
  return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
  n |= (n >> 1);
  n |= (n >> 2);
  n |= (n >> 4);
  n |= (n >> 8);
  n |= (n >> 16);
  n |= (n >> 32);
  return n - (n >> 1);
}
int hbitk(int n) {
  int k = 0;
  rer(i, 5) {
    int a = k + (1ll << i);
    int b = 1ll << a;
    if (b <= n)
      k += 1ll << i;
  }
  return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int 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を返す
vl bitCombList(int n, int r) {
  vl res;
  int m = 0;
  while (nextComb(m, n, r)) {
    res.pb(m);
  }
  return res;
}
char itoal(int i) { return 'a' + i; }
char itoaL(int i) { return 'A' + i; }
int altoi(char c) {
  if ('A' <= c && c <= 'Z')
    return c - 'A';
  return c - 'a';
}
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
  int 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(int i) {
  vi res;
  while (i) {
    res.pb(i % 10);
    i /= 10;
  }
  rev(res);
  return res;
}
vi stov(string &a) {
  int n = sz(a);
  vi ret(n);
  rep(i, n) { ret[i] = a[i] - '0'; }
  return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
  int n = sz(a);
  vi ret(n);
  rep(i, n) ret[i] = a[i] == one;
  return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
  int n = sz(s), m = sz(s[0]);
  vector<vector<int>> res(n, vector<int>(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] := i番として圧縮されたものを返す
vi compress(vi &a) {
  vi b;
  int len = a.size();
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, umap<int, int> &map) {
  vi b;
  int len = a.size();
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i) {
    int v = a[i];
    a[i] = lower_bound(all(b), a[i]) - b.begin();
    map[v] = a[i];
  }
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r) {
  vi b;
  int len = a.size();
  fora(v, a) b.pb(v);
  fora(v, r) b.pb(v);
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (int i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  int 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;
  int len = a.size();
  fora(v, a) b.pb(v);
  fora(v, r) b.pb(v);
  fora(v, s) b.pb(v);
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (int i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  for (int i = 0; i < sz(s); ++i)
    r[i] = lower_bound(all(b), s[i]) - b.begin();
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(_vvi &a) {
  vi b;
  fora(vv, a) fora(v, vv) b.pb(v);
  sort(b);
  unique(b);
  fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  int 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.pb(v);
  sort(b);
  unique(b);
  fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
void compress(int a[], int len) {
  vi b;
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int 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 lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
template <class T> void fin(T s) { cout << s << endl, exit(0); }

// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }

ll comi(int n, int 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 comd(int n, int r) {
  static vd fac;
  if (sz(fac) < n + 1) {
    if (sz(fac) == 0)
      fac.pb(1);
    rep(i, sz(fac) - 1, n) { fac.pb(fac.back() * (i + 1)); }
  }
  if (n < r || n <= 0)
    return 0;
  return fac[n] / fac[n - r] / fac[r];
}
int gcd(int a, int b) {
  while (b)
    a %= b, swap(a, b);
  return abs(a);
}
int 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) {
  int 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;
  }
}

// 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); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }

// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
  dou ax = a.fi - b.fi;
  dou ay = a.se - b.se;
  dou cx = c.fi - b.fi;
  dou cy = c.se - b.se;
  double ret = atan2(cy, cx) - atan2(ay, ax);
  if (ret < 0)
    ret += 2 * PI;
  return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }

// 機能拡張
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, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<U> &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> set<T> &operator+=(set<T> &a, U v) {
  a.insert(v);
  return a;
}
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.pb(v);
  return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
  vector<T> ret = a;
  ret += v;
  return ret;
}
template <class T, class U> vector<T> operator+(U v, const 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) {
  fora(v, b) a += v;
  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 <typename T> void erase(vector<T> &v, unsigned int i) {
  v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
  v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
  v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int 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 int 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;
  int 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;
  int kn = sz(deli);
  std::string::size_type Pos(a.find(deli));
  int l = 0;
  while (Pos != std::string::npos) {
    if (Pos - l)
      res.pb(a.substr(l, Pos - l));
    l = Pos + kn;
    Pos = a.find(deli, Pos + kn);
  }
  if (sz(a) - l)
    res.pb(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 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);
}
//@起動時
struct initon {
  initon() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    srand((unsigned)clock() + (unsigned)time(NULL));
  };
} __initon;

//@formatter:on
// gra mint pr
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
struct BipartiteMatching {
  //    vector<int> pre, root;
  //    int pre[303],root[303];
  int *pre, *root;
  vector<vector<int>> to;
  vector<int> p, q;
  int n;
  //    BipartiteMatching(int n) : pre(n, -1), root(n, -1), to(n), p(n, -1),
  //    q(n, -1), n(n) {}
  BipartiteMatching(int n) : to(n), p(n, -1), q(n, -1), n(n) {}
  void add(int a, int b) { to[a].push_back(b); }
  int solve() {
    int res = 0;
    bool upd = true;
    while (upd) {
      upd = false;
      queue<int> s;
      for (int i = 0; i < n; ++i) {
        if (!~p[i]) {
          root[i] = i;
          s.push(i);
        }
      }
      while (!s.empty()) {
        int v = s.front();
        s.pop();
        if (~p[root[v]])
          continue;
        for (int i = 0; i < (int)to[v].size(); ++i) {
          int u = to[v][i];
          if (!~q[u]) {
            while (~u) {
              q[u] = v;
              swap(p[v], u);
              v = pre[v];
            }
            upd = true;
            ++res;
            break;
          }
          u = q[u];
          if (~pre[u])
            continue;
          pre[u] = v;
          root[u] = root[v];
          s.push(u);
        }
      }
      //            if (upd) fill(pre.begin(), pre.end(), -1),
      //            fill(root.begin(), root.end(), -1);
      if (upd)
        memset(pre, -1, sizeof(int) * n), memset(root, -1, sizeof(int) * n);
    }
    return res;
  }
};
void solve() {
  in(n);
  na2(a, b, n);
  dna2(c, d, n);
  rep(1000) {
    BipartiteMatching m(300);

    rep(i, n) {
      rep(j, n) {
        if (a[i] < c[j] && b[i] < d[j]) {
          m.add(i, j + 103);
        }
      }
    }
    cou = m.solve();
  }
  cout << cou << endl;
}

int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
  int ret = 0;
  return ret;
}

signed main() {
  solve();

#define arg n, a
#ifdef _DEBUG
  bool bad = 0;
  for (int i = 0, ok = 1; i < k5 && ok; i++) {
    int n = rand(1, 8);
    vi a = ranv(n, 1, 10);
    int myres = my(arg);
    int res = sister(arg);
    ok = myres == res;
    if (!ok) {
      out(arg);
      cerr << "正解 : " << res << endl;
      cerr << "自分  : " << myres << endl;
      bad = 1;
      break;
    }
  }
  if (!bad) {
    //        cout << "完璧 : solveを書き直そう" << endl;
    //        cout << "     : そして、solve()を呼び出すのだ" << endl;
    //        cout << "     : cin>>n; na(a,n);も忘れるな" << endl;
  }
#endif
  return 0;
};


Fixed submission:
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
// 衝突対策
#define ws wszzzz
#define int long long

//@formatter:off
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;
  }
  int operator[](int i) {
    assert(i < 4);
    return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
  }
};
typedef T2<int, int, int> T;
typedef F2<int, int, int, int> F;
T mt(int a, int b, int c) { return T(a, b, c); }

//@マクロ省略系 型,構造
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define elf else if

#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 lamb(right) [&](int p) { return p right; }

// マクロ省略系 コンテナ

using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...)                                                               \
  _overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)

using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)

using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)

using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)

using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)

using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)

using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)

using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)

#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))

#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>

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<int>(__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 PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap

// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define rep1(n) for (int rep1i = 0, _lim = n; rep1i < _lim; rep1i++)
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...)                                                               \
  _overloadrep(__VA_ARGS__, repadd, repi, _rep, rep1)(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)

#define reps2(i, j, n)                                                         \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n)                                                      \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)                                             \
      for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n)                                                   \
  for (int i = 0, _lim = n; i < _lim; i++)                                     \
    for (int j = 0; j < _lim; j++)                                             \
      for (int k = 0; k < _lim; k++)                                           \
        for (int l = 0; l < _lim; l++)

#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...)                                                              \
  _overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)

#define repss(i, j, k, a, b, c)                                                \
  for (int i = 0; i < a; i++)                                                  \
    for (int j = 0; j < b; j++)                                                \
      for (int k = 0; k < c; k++)

#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve)                                                           \
  for (int gi = 0, _lim = ve.size(), f, t, c;                                  \
       gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve)                                                           \
  for (int gi = 0, f, t, c;                                                    \
       gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true);     \
       gi++)                                                                   \
    if (t != p)

#define form(st, l, r)                                                         \
  for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r)                                                        \
  for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)

// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};

// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
#define mp make_pair
#define pb push_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(int a) { return !(a & 1); }
constexpr bool od(int 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 まとめ
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 << endl;
  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 (int 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 (int i = 0; i < vec.size(); i++) {
    for (int j = 0; j < vec[0].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 <typename V, typename H> void resize(vector<V> &vec, const H head) {
  vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
  vec.resize(head);
  for (auto &v : vec)
    resize(v, tail...);
}
template <typename T, typename F> bool all_of(const vector<T> &v, F f) {
  return std::all_of(v.begin(), v.end(), f);
}
template <typename T, typename F> bool any_of(const vector<T> &v, F f) {
  return std::any_of(v.begin(), v.end(), f);
}
template <typename T, typename F> bool none_of(const vector<T> &v, F f) {
  return std::none_of(v.begin(), v.end(), f);
}
template <typename T, typename F> int find_if(const vector<T> &v, F f) {
  return std::find_if(v.begin(), v.end(), f) - v.begin();
}
template <typename T, typename F> int rfind_if(const vector<T> &v, F f) {
  return sz(v) - 1 - (find_if(v.rbegin(), v.rend(), f) - v.rbegin());
}
template <class T> bool contains(const string &s, const T &v) {
  return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
  return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if(const vector<T> &v, F f) {
  return find_if(v.begin(), v.end(), f) != v.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
  replace(a.begin(), a.end(), 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;
  int kn = sz(key);
  std::string::size_type Pos(a.find(key));
  int 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<int> &ve, int s, int n) {
  ve.resize(n);
  iota(all(ve), s);
}
vi iota(int s, int 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)); }
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;
}
// 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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), [&](int x, int 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 (int i = 0, n = a.size(); i < n; i++)
    sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
  for (int i = 0, n = a.size(); i < n; i++)
    rsort(a[i]);
}

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 V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
  for (auto &&vx : vecc)
    fill(vx, vall);
}
template <class T, class U> void fill(vector<T> &a, U val, vi &ind) {
  fora(v, ind) a[v] = val;
}
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;
}
//@汎用便利関数 入力
int in() {
  int 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 _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a)                                                                \
  int a;                                                                       \
  cin >> a
#define din2(a, b)                                                             \
  int a, b;                                                                    \
  cin >> a >> b
#define din3(a, b, c)                                                          \
  int a, b, c;                                                                 \
  cin >> a >> b >> c
#define din4(a, b, c, d)                                                       \
  int a, b, c, d;                                                              \
  cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)

#define _overloaddind(_1, _2, _3, _4, name, ...) name
#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(...)                                                              \
  _overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)

#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...)                                                               \
  _overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))

template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
template <class T> void na(vector<T> &a, int n) {
  a.resize(n);
  rep(i, n) cin >> a[i];
}
#define dna(a, n)                                                              \
  vi a(n);                                                                     \
  rep(_i, n) cin >> a[_i];
template <class T> void nao(vector<T> &a, int n) {
  a.resize(n + 1);
  a[0] = 0;
  rep(i, n) cin >> a[i + 1];
}
template <class T> void nad(vector<T> &a, int n) {
  a.resize(n);
  rep(i, n) cin >> a[i], a[i]--;
}
template <class T, class U> void na2(vector<T> &a, vector<U> &b, int n) {
  a.resize(n);
  b.resize(n);
  rep(i, n) cin >> a[i] >> b[i];
}
#define dna2(a, b, n)                                                          \
  vi a(n), b(n);                                                               \
  rep(_i, n) cin >> a[_i] >> b[_i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, int n) {
  a.resize(n + 1);
  b.resize(n + 1);
  a[0] = b[0] = 0;
  rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, int 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 V>
void na3(vector<T> &a, vector<U> &b, vector<V> &c, int 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(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
template <class T, class U, class V>
void na3d(vector<T> &a, vector<U> &b, vector<V> &c, int 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(_i, n) {                                                                 \
    cin >> a[_i] >> b[_i] >> c[_i];                                            \
    a[_i]--, b[_i]--, c[_i]--;                                                 \
  }
#define nt(a, h, w)                                                            \
  resize(a, h, w);                                                             \
  rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w)                                                           \
  rs(a, h, w);                                                                 \
  rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w)                                                           \
  resize(a, h + 2, w + 2);                                                     \
  fill(a, '#');                                                                \
  rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];

// デバッグ
#define sp << " " <<

#define debugName(VariableName) #VariableName

#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__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__)

#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name

#ifdef _DEBUG
#define deb(...)                                                               \
  cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6,       \
                        _deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__)        \
       << endl
#else
#define deb(...) ;
#endif

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

// よく使うクラス、構造体
class UnionFind {
public:
  vi par, rank, sizes;
  int n, trees;
  UnionFind(int n) : n(n), trees(n) {
    par.resize(n), rank.resize(n), sizes.resize(n);
    rep(i, n) par[i] = i, sizes[i] = 1;
  }
  int root(int x) {
    if (par[x] == x)
      return x;
    else
      return par[x] = root(par[x]);
  }
  int find(int x) { return root(x); }
  void unite(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return;
    if (rank[x] < rank[y])
      swap(x, y);
    trees--;
    par[y] = x;
    sizes[x] += sizes[y];
    if (rank[x] == rank[y])
      rank[x]++;
  }
  bool same(int x, int y) { return root(x) == root(y); }
  int size(int x) { return sizes[root(x)]; }
  // 順不同 umapなので
  vec<vi> sets() {
    vec<vi> res(trees);
    umap<int, vi> map;
    rep(i, n) map[root(i)].push_back(i);
    int i = 0;
    for (auto &&p : map) {
      int r = p.fi;
      res[i].push_back(r);
      for (auto &&v : p.se) {
        if (r == v)
          continue;
        res[i].push_back(v);
      }
      i++;
    }
    return res;
  }
};

using bint = __int128;
using u32 = unsigned int;
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 = '-';
    }
    int 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 (int 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;
}

// 便利関数

// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int 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);
    }
  }
}
vi ranv(int n, int min, int max) {
  vi v(n);
  rep(i, n) v[i] = rand(min, max);
  return v;
}
str ransu(int n) {
  str s;
  rep(i, n) s += (char)rand('A', 'Z');
  return s;
}
str ransl(int n) {
  str s;
  rep(i, n) s += (char)rand('a', 'z');
  return s;
}
// 単調増加
vi ranvinc(int n, int min, int 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(int n, int min, int 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]);
  }
}
vp run_length(vi &a) {
  vp 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, int>> run_length(string &a) {
  vector<pair<char, 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;
}
template <class F> int mgr(int ok, int ng, F f) {
  if (ok < ng)
    while (ng - ok > 1) {
      int mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid;
      else
        ng = mid;
    }
  else
    while (ok - ng > 1) {
      int mid = (ok + ng) / 2;
      if (f(mid))
        ok = mid;
      else
        ng = mid;
    }
  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 {
    rep(i, sz(a)) {
      if (a[i] < b[i]) {
        return b;
      } else if (a[i] > b[i])
        return a;
    }
  }
  return a;
}
// strを整数として比較
string smin(str &a, str b) {
  if (sz(a) < sz(b)) {
    return a;
  } else if (sz(a) > sz(b)) {
    return b;
  } else {
    rep(i, sz(a)) {
      if (a[i] < b[i]) {
        return a;
      } else if (a[i] > b[i])
        return b;
    }
  }
  return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
  rep(i, sz(a)) if (a[i] == key) return i;
  return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &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 V, typename U>
T find(vector<vector<vector<V>>> &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);
}

template <typename T, typename F> int count_if(const T &v, F f) { return f(v); }
template <typename T, typename F> int count_if(const vector<T> &vec, F f) {
  int ret = 0;
  fora(v, vec) ret += count_if(v, f);
  return ret;
}

template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
  int ret = 0;
  fora(v, a) ret += count(v, k);
  return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
  int ret = 0;
  fora(v, a) ret += count2(v, k);
  return ret;
}
int count(str a, str k) {
  int ret = 0, len = k.length();
  auto pos = a.find(k);
  while (pos != string::npos)
    pos = a.find(k, pos + len), ret++;
  return ret;
}
template <typename V> int count_od(vector<V> &a) {
  return count_if(a, [](int v) { return v & 1; });
}
template <typename V> int count_ev(vector<V> &a) {
  return count_if(a, [](int v) { return !(v & 1); });
}
#define couif count_if
// algorythm

inline 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 T> vector<T> revv(vector<T> &a) {
  vector<T> b = a;
  reverse(all(b));
  return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
                       10,
                       100,
                       1000,
                       10000,
                       100000,
                       1000000,
                       10000000,
                       100000000,
                       1000000000,
                       10000000000ll,
                       100000000000ll,
                       1000000000000ll,
                       10000000000000ll,
                       100000000000000ll,
                       1000000000000000ll,
                       10000000000000000ll,
                       100000000000000000ll,
                       1000000000000000000ll};

int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
  if (v < p10[9]) {
    if (v < p10[4]) {
      if (v < p10[2]) {
        if (v < p10[1])
          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 if (v < p10[15])
          return 15;
        else
          return 16;
      } else {
        if (v < p10[17])
          return 17;
        else
          return 18;
      }
    }
  }
}
int dsum(int v) {
  int ret = 0;
  for (; v; v /= 10)
    ret += v % 10;
  return ret;
}

struct sint {
  int v;
  sint(int v) : v(v) {}
  operator int() { return v; }
  // 下からi番目
  int operator[](int i) { return (v / p10[i]) % 10; }
  int back(int i) { return operator[](i); }
  // 上からi番目
  int top(int i) {
    int len = keta(v);
    return operator[](len - 1 - i);
  }
  // 先頭からi番目にセット
  int settop(int i, int k) {
    int len = keta(v);
    return set(len - 1 - i, k);
  }
  int set(int i, int k) {
    if (i < 0)
      return settop(abs(i) - 1, k);
    return v += p10[i] * (k - (v / p10[i]) % 10);
  }
  int add(int i, int k = 1) { return v += p10[i] * k; }
  int addtop(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
  int dec(int i, int k = 1) { return v -= p10[i] * k; }
  int dectop(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o)                                                               \
  template <class T> inline t operator o(T r) { return v o r; }
  op(int, +=);
  op(int, -=);
  op(int, *=);
  op(int, /=);
  op(int, %=);
  op(int, +);
  op(int, -);
  op(int, *);
  op(int, /);
  op(int, %);
  op(bool, ==);
  op(bool, !=);
  op(bool, <);
  op(bool, <=);
  op(bool, >);
  op(bool, >=);
#undef op
  template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
  template <class T> inline int operator<<(T r) { return v * p10[r]; }
  template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
  template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T> auto keys(T a) {
  vector<decltype((a.begin())->fi)> res;
  for (auto &&k : a)
    res.pb(k.fi);
  return res;
}
template <class T> auto values(T a) {
  vector<decltype((a.begin())->se)> res;
  for (auto &&k : a)
    res.pb(k.se);
  return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
  return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
  return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
  return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
  return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
  return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
  return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
  return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
  return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline 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> inline 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>
inline 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>
inline 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>
inline 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>
inline 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> inline 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> inline A min(A (&a)[N][O]) {
  A res = min(a[0]);
  rep(i, N) res = min(res, max(a[i]));
  return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline 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>
inline 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>
inline 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>
inline 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) {
  T ret = 0;
  rep(i, sz(v)) ret += v[i];
  return ret;
}
template <class T> T sum(vector<vector<T>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
template <class T> T sum(vector<vector<vector<vector<vector<T>>>>> &v) {
  T ret = 0;
  rep(i, sz(v)) ret += sum(v[i]);
  return ret;
}
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... V>
inline auto sum(vector<T> &v, U head, V... tail) {
  auto ret = sum(v[0], tail...);
  rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
  return ret;
}
void clear(PQ &q) {
  while (q.size())
    q.pop();
}
template <class T> void clear(queue<T> &q) {
  while (q.size())
    q.pop();
}
template <class T> T *negarr(int size) {
  T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
  return body + size;
}
template <class T> T *negarr2(int h, int w) {
  double **dummy1 = new double *[2 * h + 1];
  double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
  dummy1[0] = dummy2 + w;
  for (int 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 imocou(vector<T> &a, U k) {
  vector<T> ret = a;
  rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
  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> struct ruiC {
  const vector<T> rui;
  ruiC(vector<T> &ru) : rui(ru) {}
  inline T operator()(int l, int r) {
    assert(l <= r);
    return rui[r] - rui[l];
  }
  inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
  const T *rrui;
  rruic(T *ru) : rrui(ru) {}
  inline T operator()(int l, int r) {
    assert(l >= r);
    return rrui[r] - rrui[l];
  }
  inline T operator[](int i) { return rrui[i]; }
};
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(vector<T> &a) {
  vector<T> ret = ruiv(a);
  return ruiC<T>(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<int> ruic(T &a, U k) {
  vi ret = ruiv(a, k);
  return ruiC<int>(ret);
}

// xor
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> 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) {
  int 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> rruic<T> rrui(vector<T> &a) {
  int len = a.size();
  T *body = (T *)malloc((len + 1) * sizeof(T));
  T *res = body + 1;
  rer(i, len - 1) res[i - 1] = res[i] + a[i];
  return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
  int 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(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 T> void dec(vector<T> &a) {
  for (auto &u : a)
    dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
template <class T> void minu(vector<T> &a) {
  for (auto &u : a)
    dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
  for (auto &u : a)
    dec(u, v);
}
void minu(string &a) {
  for (auto &u : a)
    dec(u, 1);
}
bool inside(int h, int w, int H, int W) {
  return h >= 0 && w >= 0 && h < H && w < W;
}
bool inside(int l, int v, int r) { return l <= v && v < r; }
template <class T> bool inside(vector<T> &a, int i, int j = 0) {
  return inside(0, i, sz(a)) && inside(0, j, sz(a));
}
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
  vector<T> ret = a;
  fora(v, ret) v = u(v);
  return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> 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;
}
ll goldt(ll left, ll right, function<ll(ll)> 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;
}
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;
}

constexpr bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
  m /= (ll)pow(sinsuu, keta);
  return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
  n |= (n >> 1);
  n |= (n >> 2);
  n |= (n >> 4);
  n |= (n >> 8);
  n |= (n >> 16);
  n |= (n >> 32);
  return n - (n >> 1);
}
int hbitk(int n) {
  int k = 0;
  rer(i, 5) {
    int a = k + (1ll << i);
    int b = 1ll << a;
    if (b <= n)
      k += 1ll << i;
  }
  return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int 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を返す
vl bitCombList(int n, int r) {
  vl res;
  int m = 0;
  while (nextComb(m, n, r)) {
    res.pb(m);
  }
  return res;
}
char itoal(int i) { return 'a' + i; }
char itoaL(int i) { return 'A' + i; }
int altoi(char c) {
  if ('A' <= c && c <= 'Z')
    return c - 'A';
  return c - 'a';
}
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
  int 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(int i) {
  vi res;
  while (i) {
    res.pb(i % 10);
    i /= 10;
  }
  rev(res);
  return res;
}
vi stov(string &a) {
  int n = sz(a);
  vi ret(n);
  rep(i, n) { ret[i] = a[i] - '0'; }
  return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
  int n = sz(a);
  vi ret(n);
  rep(i, n) ret[i] = a[i] == one;
  return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
  int n = sz(s), m = sz(s[0]);
  vector<vector<int>> res(n, vector<int>(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] := i番として圧縮されたものを返す
vi compress(vi &a) {
  vi b;
  int len = a.size();
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i) {
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  }
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, umap<int, int> &map) {
  vi b;
  int len = a.size();
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i) {
    int v = a[i];
    a[i] = lower_bound(all(b), a[i]) - b.begin();
    map[v] = a[i];
  }
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(vi &a, vi &r) {
  vi b;
  int len = a.size();
  fora(v, a) b.pb(v);
  fora(v, r) b.pb(v);
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (int i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  int 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;
  int len = a.size();
  fora(v, a) b.pb(v);
  fora(v, r) b.pb(v);
  fora(v, s) b.pb(v);
  sort(b);
  unique(b);
  for (int i = 0; i < len; ++i)
    a[i] = lower_bound(all(b), a[i]) - b.begin();
  for (int i = 0; i < sz(r); ++i)
    r[i] = lower_bound(all(b), r[i]) - b.begin();
  for (int i = 0; i < sz(s); ++i)
    r[i] = lower_bound(all(b), s[i]) - b.begin();
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
vi compress(_vvi &a) {
  vi b;
  fora(vv, a) fora(v, vv) b.pb(v);
  sort(b);
  unique(b);
  fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  int 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.pb(v);
  sort(b);
  unique(b);
  fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
  int blen = sz(b);
  vi ret(blen);
  rep(i, blen) { ret[i] = b[i]; }
  return ret;
}
void compress(int a[], int len) {
  vi b;
  for (int i = 0; i < len; ++i) {
    b.push_back(a[i]);
  }
  sort(b);
  unique(b);
  for (int 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 lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
template <class T> void fin(T s) { cout << s << endl, exit(0); }

// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }

ll comi(int n, int 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 comd(int n, int r) {
  static vd fac;
  if (sz(fac) < n + 1) {
    if (sz(fac) == 0)
      fac.pb(1);
    rep(i, sz(fac) - 1, n) { fac.pb(fac.back() * (i + 1)); }
  }
  if (n < r || n <= 0)
    return 0;
  return fac[n] / fac[n - r] / fac[r];
}
int gcd(int a, int b) {
  while (b)
    a %= b, swap(a, b);
  return abs(a);
}
int 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) {
  int 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;
  }
}

// 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); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }

// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
  dou ax = a.fi - b.fi;
  dou ay = a.se - b.se;
  dou cx = c.fi - b.fi;
  dou cy = c.se - b.se;
  double ret = atan2(cy, cx) - atan2(ay, ax);
  if (ret < 0)
    ret += 2 * PI;
  return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }

// 機能拡張
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, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<U> &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> set<T> &operator+=(set<T> &a, U v) {
  a.insert(v);
  return a;
}
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.pb(v);
  return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
  vector<T> ret = a;
  ret += v;
  return ret;
}
template <class T, class U> vector<T> operator+(U v, const 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) {
  fora(v, b) a += v;
  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 <typename T> void erase(vector<T> &v, unsigned int i) {
  v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
  v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
  m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
  v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int 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 int 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;
  int 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;
  int kn = sz(deli);
  std::string::size_type Pos(a.find(deli));
  int l = 0;
  while (Pos != std::string::npos) {
    if (Pos - l)
      res.pb(a.substr(l, Pos - l));
    l = Pos + kn;
    Pos = a.find(deli, Pos + kn);
  }
  if (sz(a) - l)
    res.pb(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 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);
}
//@起動時
struct initon {
  initon() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    srand((unsigned)clock() + (unsigned)time(NULL));
  };
} __initon;

//@formatter:on
// gra mint pr
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
struct BipartiteMatching {
  //    vector<int> pre, root;
  //    int pre[303],root[303];
  int *pre, *root;
  vector<vector<int>> to;
  vector<int> p, q;
  int n;
  //    BipartiteMatching(int n) : pre(n, -1), root(n, -1), to(n), p(n, -1),
  //    q(n, -1), n(n) {}
  BipartiteMatching(int n) : to(n), p(n, -1), q(n, -1), n(n) {
    // #define MALLOC(type, len) (type*)malloc((len) * sizeof(type))
    pre = MALLOC(int, n);
    root = MALLOC(int, n);
  }
  void add(int a, int b) { to[a].push_back(b); }
  int solve() {
    int res = 0;
    bool upd = true;
    while (upd) {
      upd = false;
      queue<int> s;
      for (int i = 0; i < n; ++i) {
        if (!~p[i]) {
          root[i] = i;
          s.push(i);
        }
      }
      while (!s.empty()) {
        int v = s.front();
        s.pop();
        if (~p[root[v]])
          continue;
        for (int i = 0; i < (int)to[v].size(); ++i) {
          int u = to[v][i];
          if (!~q[u]) {
            while (~u) {
              q[u] = v;
              swap(p[v], u);
              v = pre[v];
            }
            upd = true;
            ++res;
            break;
          }
          u = q[u];
          if (~pre[u])
            continue;
          pre[u] = v;
          root[u] = root[v];
          s.push(u);
        }
      }
      //            if (upd) fill(pre.begin(), pre.end(), -1),
      //            fill(root.begin(), root.end(), -1);
      if (upd)
        memset(pre, -1, sizeof(int) * n), memset(root, -1, sizeof(int) * n);
    }
    return res;
  }
};
void solve() {
  in(n);
  na2(a, b, n);
  dna2(c, d, n);
  rep(1000) {
    BipartiteMatching m(300);

    rep(i, n) {
      rep(j, n) {
        if (a[i] < c[j] && b[i] < d[j]) {
          m.add(i, j + 103);
        }
      }
    }
    cou = m.solve();
  }
  cout << cou << endl;
}

int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
  int ret = 0;
  return ret;
}

signed main() {
  solve();

#define arg n, a
#ifdef _DEBUG
  bool bad = 0;
  for (int i = 0, ok = 1; i < k5 && ok; i++) {
    int n = rand(1, 8);
    vi a = ranv(n, 1, 10);
    int myres = my(arg);
    int res = sister(arg);
    ok = myres == res;
    if (!ok) {
      out(arg);
      cerr << "正解 : " << res << endl;
      cerr << "自分  : " << myres << endl;
      bad = 1;
      break;
    }
  }
  if (!bad) {
    //        cout << "完璧 : solveを書き直そう" << endl;
    //        cout << "     : そして、solve()を呼び出すのだ" << endl;
    //        cout << "     : cin>>n; na(a,n);も忘れるな" << endl;
  }
#endif
  return 0;
};