結果

問題 No.2605 Pickup Parentheses
ユーザー uwi
提出日時 2024-01-12 22:48:53
言語 Java
(openjdk 23)
結果
AC  
実行時間 1,147 ms / 2,000 ms
コード長 27,224 bytes
コンパイル時間 4,842 ms
コンパイル使用メモリ 94,724 KB
実行使用メモリ 85,064 KB
最終ジャッジ日時 2024-09-30 06:29:17
合計ジャッジ時間 27,699 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 68
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

package no2xxx;
import java.io.*;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
public class No2605 {
    InputStream is;
    FastWriter out;
    String INPUT = "";
    public void solve()
    {
        // 2236
        // coding:11m
        int n = ni(), m = ni();
        if(n % 2 == 1){
            out.println(0);
            return;
        }
        int[][] lr = nmi(m, 2);
        List<long[]> ps = new ArrayList<>();
        int[][] fif = enumFIF(200000, mod);
        for(int[] u : lr){
            if((u[1] - u[0] + 1) % 2 == 0){
                int len = (u[1] - u[0] + 1);
                long c = catalan(len, mod, fif);
                long[] p = new long[len+1];
                p[len] = mod - c;
                p[0] = 1;
                ps.add(p);
            }
        }
        long[] pm = mulAll(ps);
        long ans = 0;
        for(int i = 0;i < pm.length;i++){
            ans += pm[i] * catalan(n-i, mod, fif);
            ans %= mod;
        }
        out.println(ans);
    }
    static long catalan(int n, int mod, int[][] fif) {
        if(n % 2 == 1)return 0;
        n /= 2;
        return C(2*n, n, mod, fif) * invl(n+1, mod) % mod;
    }
    public static final int mod = 998244353;
    public static final int G = 3;
    // only 998244353
    public static long[] mul(long[] a, long[] b)
    {
        if(a.length == 0 && b.length == 0)return new long[0];
        if(a.length + b.length >= 300) {
            return Arrays.copyOf(NTTStockham998244353.convolve(a, b), a.length + b.length - 1);
        }else{
            return mulnaive(a, b);
        }
    }
    public static long[] mul(long[] a, long[] b, int lim)
    {
        if(a.length + b.length >= 300) {
            return Arrays.copyOf(NTTStockham998244353.convolve(a, b), lim);
        }else{
            return mulnaive(a, b, lim);
        }
    }
//  public static final int mod = 1000000007;
//  public static long[] mul(long[] a, long[] b)
//  {
//      if(Math.max(a.length, b.length) >= 3000){
//          return Arrays.copyOf(NTTCRT.convolve(a, b, 3, mod), a.length+b.length-1);
//      }else{
//          return mulnaive(a, b);
//      }
//  }
//  public static long[] mul(long[] a, long[] b, int lim)
//  {
//      if(Math.max(a.length, b.length) >= 3000){
//          return Arrays.copyOf(NTTCRT.convolve(a, b, 3, mod), lim);
//      }else{
//          return mulnaive(a, b, lim);
//      }
//  }
    public static final long big = (Long.MAX_VALUE/mod/mod-1)*mod*mod;
    public static long[] mulnaive(long[] a, long[] b)
    {
        long[] c = new long[a.length+b.length-1];
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < b.length;j++){
                c[i+j] += a[i]*b[j];
                if(c[i+j] >= big)c[i+j] -= big;
            }
        }
        for(int i = 0;i < c.length;i++)c[i] %= mod;
        return c;
    }
    public static long[] mulnaive(long[] a, long[] b, int lim)
    {
        long[] c = new long[lim];
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < b.length && i+j < lim;j++){
                c[i+j] += a[i]*b[j];
                if(c[i+j] >= big)c[i+j] -= big;
            }
        }
        for(int i = 0;i < c.length;i++)c[i] %= mod;
        return c;
    }
    public static long[] mul_(long[] a, long k)
    {
        for(int i = 0;i < a.length;i++)a[i] = a[i] * k % mod;
        return a;
    }
    public static long[] mul(long[] a, long k)
    {
        a = Arrays.copyOf(a, a.length);
        for(int i = 0;i < a.length;i++)a[i] = a[i] * k % mod;
        return a;
    }
    public static long[] add(long[] a, long[] b)
    {
        long[] c = new long[Math.max(a.length, b.length)];
        for(int i = 0;i < a.length;i++)c[i] += a[i];
        for(int i = 0;i < b.length;i++)c[i] += b[i];
        for(int i = 0;i < c.length;i++)if(c[i] >= mod)c[i] -= mod;
        return c;
    }
    public static long[] add(long[] a, long[] b, int lim)
    {
        long[] c = new long[lim];
        for(int i = 0;i < a.length && i < lim;i++)c[i] += a[i];
        for(int i = 0;i < b.length && i < lim;i++)c[i] += b[i];
        for(int i = 0;i < c.length;i++)if(c[i] >= mod)c[i] -= mod;
        return c;
    }
    public static long[] sub(long[] a, long[] b)
    {
        long[] c = new long[Math.max(a.length, b.length)];
        for(int i = 0;i < a.length;i++)c[i] += a[i];
        for(int i = 0;i < b.length;i++)c[i] -= b[i];
        for(int i = 0;i < c.length;i++)if(c[i] < 0)c[i] += mod;
        return c;
    }
    public static long[] sub(long[] a, long[] b, int lim)
    {
        long[] c = new long[lim];
        for(int i = 0;i < a.length && i < lim;i++)c[i] += a[i];
        for(int i = 0;i < b.length && i < lim;i++)c[i] -= b[i];
        for(int i = 0;i < c.length;i++)if(c[i] < 0)c[i] += mod;
        return c;
    }
    public static long[] truncateTrailingZeros(long[] a)
    {
        int tz = trailingZeros(a);
        if(tz == 0)return a;
        return Arrays.copyOfRange(a, tz, a.length);
    }
    public static long[] strip(long[] a)
    {
        int i;
        for(i = a.length-1;i > 0 && a[i] == 0;i--);
        if(i + 1 == a.length)return a;
        return Arrays.copyOf(a, i+1);
    }
    public static long[] lshift(long[] a, int x)
    {
        long[] b = new long[a.length];
        if (a.length - x >= 0) System.arraycopy(a, x, b, 0, a.length - x);
        return b;
    }
    public static long[] rshift(long[] a, int x)
    {
        long[] b = new long[a.length];
        if (a.length - x >= 0) System.arraycopy(a, 0, b, x, a.length - x);
        return b;
    }
    ///////////////////// 基本操作ここまで
    // F_{t+1}(x) = -F_t(x)^2*P(x) + 2F_t(x)
    // if want p-destructive, comment out flipping p just before returning.
    public static long[] inv(long[] p)
    {
        int n = p.length;
        long[] f = {invl(p[0], mod)};
        for(int i = 0;i < p.length;i++){
            if(p[i] == 0)continue;
            p[i] = mod-p[i];
        }
        for(int i = 1;i < 2*n;i*=2){
            long[] f2 = mul(f, f, Math.min(n, 2*i));
            long[] f2p = mul(f2, Arrays.copyOf(p, i), Math.min(n, 2*i));
            for(int j = 0;j < f.length;j++){
                f2p[j] += 2L*f[j];
                if(f2p[j] >= mod)f2p[j] -= mod;
                if(f2p[j] >= mod)f2p[j] -= mod;
            }
            f = f2p;
        }
        for(int i = 0;i < p.length;i++){
            if(p[i] == 0)continue;
            p[i] = mod-p[i];
        }
        return f;
    }
    // differentiate
    public static long[] d(long[] p)
    {
        long[] q = new long[p.length];
        for(int i = 0;i < p.length-1;i++){
            q[i] = p[i+1] * (i+1) % mod;
        }
        return q;
    }
    // integrate
    public static long[] i(long[] p)
    {
        long[] q = new long[p.length];
        for(int i = 0;i < p.length-1;i++){
            q[i+1] = p[i] * invl(i+1, mod) % mod;
        }
        return q;
    }
    static long[] exp(long[] a) { return exp(a, a.length); }
    /**
     * https://cs.uwaterloo.ca/~eschost/publications/BoSc09-final.pdf
     * @verified https://judge.yosupo.jp/problem/exp_of_formal_power_series
     * @param a
     * @param lim
     * @return
     */
    static long[] exp(long[] a, int lim)
    {
        long[] F = {1L};
        long[] G = {1L};
        long[] da = d(a);
        for(int m = 1;;m *= 2) {
            long[] G2 = mul(G, G, m);
            G = sub(mul_(G, 2), mul(F, G2, m));
            long[] Q = Arrays.copyOf(da, m-1);
            long[] W = add(Q, mul(G, sub(d(F), mul(F, Q, m), m-1)));
            F = mul(F, add(new long[] {1}, sub(Arrays.copyOf(a, m), i(W))), m);
            if(m >= lim)break;
        }
        return Arrays.copyOf(F, lim);
    }
    // \int f'(x)/f(x) dx
    public static long[] ln(long[] f)
    {
        return i(mul(d(f), inv(f)));
    }
    // ln F(x) - k ln P(x) = 0
    public static long[] pow(long[] p, long K)
    {
        int n = p.length;
        int tz = trailingZeros(p);
        if((long)tz*K >= n)return new long[n];
        long[] pa = Arrays.copyOfRange(p, tz, n);
        int m = pa.length;
        // pa[0] must be 1
        long base = pa[0];
        long scale = invl(base, mod);
        for(int i = 0;i < m;i++)pa[i] = pa[i] * scale % mod;
        long[] lnp = Arrays.copyOf(ln(pa), m);
        for(int i = 0;i < m;i++)lnp[i] = lnp[i] * K % mod;
        long[] reta = exp(lnp);
        long kscale = pow(base, K, mod);
        for(int i = 0;i < m;i++)reta[i] = reta[i] * kscale % mod;
        long[] ret = new long[n];
        System.arraycopy(reta, 0, ret, (int)(tz*K), (int)(n-tz*K));
        return ret;
    }
    public static int trailingZeros(long[] a)
    {
        int ret = 0;
        for(long v : a) {
            v %= mod;
            if(v != 0)break;
            ret++;
        }
        return ret;
    }
    public static long[] pow(long[] P, int n, int m)
    {
        long[] PP = truncateTrailingZeros(P);
        if(PP.length == P.length)return powCore(P, n, m);
        assert n >= 0;
        long[] res = powCore(PP, n, m);
        long[] ret = new long[m+1];
        for(int i = 0, j = (P.length - PP.length) * n;j <= m;i++,j++)ret[j] = res[i];
        return ret;
    }
    /**
     * P(x)^nをm次まで求める。
     *
     * Q(x)=P(x)^nとすると、
     * Q'(x)=nP'(x)P(x)^{n-1}である。したがって、
     * Q(x) = P(x) * Q'(x)/n/P'(x)
     * nP'(x)Q(x) = P(x)Q'(x)である。
     * これのx^iの係数は、
     * n(sum_j (i-j+1)p[i-j+1]*q[j]) = sum_j p[i-j]*(j+1)q[j+1]
     * となる。
     * ここから、
     * q[i+1] = (n(sum_j (i-j+1)p[i-j+1]*q[j]) - sum_{j=0}^{i-1} p[i-j]*(j+1)q[j+1]) / p[0] / (i+1)
     * が導かれる。sumは、iが大きくなっても|P|で抑えられるので、全体でO(|P|m)になる。
     * 0<=i-j+1<|P| -> i+1-|P|<j<=i+1
     *
     * またこれはnが負のときでも成立する。
     *
     * @param P P[0] != 0
     * @param n
     * @param m
     * @return
     */
    public static long[] powCore(long[] P, int n, int m)
    {
        long[] Q = new long[m+1];
        long ip0 = invl(P[0], mod);
        Q[0] = n >= 0 ? pow(P[0], n, mod) : pow(ip0, n, mod);
        for(int i = 0;i < m;i++){
            long s = 0;
            for(int j = Math.max(0, i+1-P.length+1);j <= i;j++){
                s += (i-j+1) * P[i-j+1] % mod * Q[j];
                if(s >= big)s -= big;
            }
            s %= mod;
            long t = 0;
            for(int j = Math.max(0, i-P.length+1);j <= i-1;j++){
                t += (j+1) * P[i-j] % mod * Q[j+1];
                if(t >= big)t -= big;
            }
            t %= mod;
            s = (s*n-t) % mod;
            if(s < 0)s += mod;
            Q[i+1] = s * ip0 % mod * invl(i+1, mod) % mod;
        }
        return Q;
    }
    /**
     * Pがsparseな場合のP^nをm次まで
     * O(|P|m).
     * NOT VERIFIED
     *
     * @param P [index, value] P[0] != 0
     * @param n
     * @param m
     * @return
     */
    public static long[] pow(long[][] P, int n, int m)
    {
        long[] Q = new long[m+1];
        long p0 = 0;
        for(long[] u : P)if(u[0] == 0)p0 = u[1];
        assert p0 != 0;
        long ip0 = invl(p0, mod);
        Q[0] = n >= 0 ? pow(p0, n, mod) : pow(ip0, n, mod);
        for(int i = 0;i < m;i++){
            long s = 0;
            for (long[] u : P) {
                if (Math.max(0, i + 1 - P.length + 1) <= i - u[0] + 1 && i - u[0] + 1 <= i) {
                    s += u[0] * u[1] % mod * Q[i - (int) u[0] + 1];
                    if(s >= big)s -= big;
                }
            }
            s %= mod;
            long t = 0;
            for(long[] u : P) {
                if (Math.max(0, i - P.length + 1) <= i - u[0] && i - u[0] <= i - 1) {
                    t += (i-u[0]+1) * u[1] % mod * Q[i - (int) u[0] + 1];
                    if(t >= big)t -= big;
                }
            }
            t %= mod;
            s = (s*n-t) % mod;
            if(s < 0)s += mod;
            Q[i+1] = s * ip0 % mod * invl(i+1, mod) % mod;
        }
        return Q;
    }
    /**
     * n=500000, K=10^9でpowより1.76倍遅い
     * @param a
     * @param K
     * @return
     */
    public static long[] powNaive(long[] a, int K)
    {
        int n = a.length;
        long[] ret = {1};
        for(int d = 31-Integer.numberOfLeadingZeros(K);d >= 0;d--) {
            ret = mul(ret, ret, n);
            if(K<<~d<0) {
                ret = mul(ret, a, n);
            }
        }
        return ret;
    }
    public static long pow(long a, long n, long mod) {
        //      a %= mod;
        long ret = 1;
        int x = 63 - Long.numberOfLeadingZeros(n);
        for (; x >= 0; x--) {
            ret = ret * ret % mod;
            if (n << 63 - x < 0)
                ret = ret * a % mod;
        }
        return ret;
    }
    public static long invl(long a) {
        long b = mod;
        long p = 1, q = 0;
        while (b > 0) {
            long c = a / b;
            long d;
            d = a;
            a = b;
            b = d % b;
            d = p;
            p = q;
            q = d - c * q;
        }
        return p < 0 ? p + mod : p;
    }
    public static long invl(long a, long mod) {
        long b = mod;
        long p = 1, q = 0;
        while (b > 0) {
            long c = a / b;
            long d;
            d = a;
            a = b;
            b = d % b;
            d = p;
            p = q;
            q = d - c * q;
        }
        return p < 0 ? p + mod : p;
    }
    public static long[] reverse_(long[] p)
    {
        for(int i = 0, j = p.length-1;i < j;i++,j--){
            long d = p[i]; p[i] = p[j]; p[j] = d;
        }
        return p;
    }
    public static long[] reverse(long[] p)
    {
        long[] ret = new long[p.length];
        for(int i = 0;i < p.length;i++){
            ret[i] = p[p.length-1-i];
        }
        return ret;
    }
    public static long[] reverse(long[] p, int lim)
    {
        long[] ret = new long[lim];
        for(int i = 0;i < lim && i < p.length;i++){
            ret[i] = p[p.length-1-i];
        }
        return ret;
    }
    // [quotient, remainder]
    // remainder can be empty.
    //
    // deg(f)=n, deg(g)=m, f=gq+r, f=gq+r.
    // f* = x^n*f(1/x),
    // t=g*^-1 mod x^(n-m+1), q=(tf* mod x^(n-m+1))*
    public static long[][] div(long[] f, long[] g)
    {
        int n = f.length, m = g.length;
        if(n < m)return new long[][]{new long[0], Arrays.copyOf(f, n)};
        long[] rf = reverse(f, n-m+1);
        long[] rg = reverse(g, n-m+1);
        long[] rq = mul(rf, inv(rg), n-m+1);
        long[] q = reverse(rq, n-m+1);
        long[] r = sub(f, mul(q, g, m-1), m-1);
        return new long[][]{q, r};
    }
    public static long[] mulAll(List<long[]> sup)
    {
        if(sup.size() == 0)return new long[]{1};
        PriorityQueue<long[]> ps = new PriorityQueue<>((x, y) -> x.length - y.length);
        ps.addAll(sup);
        while(ps.size() > 1)ps.add(mul(ps.poll(), ps.poll()));
        return ps.poll();
    }
    public static class NTTStockham998244353 {
        private static final int P = 998244353, mod = P, G = 3;
        private static long[] wps;
        public static long[] convolve(long[] a, long[] b)
        {
            int m = Math.max(2, Integer.highestOneBit(Math.max(a.length, b.length)-1)<<2);
            wps = new long[m];
            long unit = pow(G, (P-1)/m);
            wps[0] = 1;
            for(int p = 1;p < m;p++) {
                wps[p] = wps[p-1] * unit % mod;
            }
            long[] fa = go(a, m, false);
            long[] fb = a == b ? fa : go(b, m, false);
            for(int i = 0;i < m;i++){
                fa[i] = fa[i]*fb[i] % mod;
            }
            fa = go(fa, m, true);
            for(int i = 1, j = m-1;i < j;i++,j--) {
                long d = fa[i]; fa[i] = fa[j]; fa[j] = d;
            }
            return fa;
        }
        private static void fft(long[] X, long[] Y)
        {
            int s = 1;
            boolean eo = false;
            for(int n = X.length;n >= 4;n /= 2) {
                int m = n/2;
                for(int p = 0;p < m;p++) {
                    long wp = wps[s*p];
                    long wk = (wp<<32)/P;
                    for(int q = 0;q < s;q++) {
                        long a = X[q + s*(p+0)];
                        long b = X[q + s*(p+m)];
                        long ndsts = a + b;
                        if(ndsts >= 2*P)ndsts -= 2*P;
                        long T = a - b + 2*P;
                        long Q = wk*T>>>32;
                        Y[q + s*(2*p+0)] = ndsts;
                        Y[q + s*(2*p+1)] = wp*T-Q*P&(1L<<32)-1;
                    }
                }
                s *= 2;
                eo = !eo;
                long[] D = X; X = Y; Y = D;
            }
            long[] z = eo ? Y : X;
            for(int q = 0;q < s;q++) {
                long a = X[q + 0];
                long b = X[q + s];
                z[q+0] = (a+b) % P;
                z[q+s] = (a-b+2*P) % P;
            }
        }
//  private static void fft(long[] X, long[] Y)
//  {
//      int s = 1;
//      boolean eo = false;
//      for(int n = X.length;n >= 4;n /= 2) {
//          int m = n/2;
//          for(int p = 0;p < m;p++) {
//              long wp = wps[s*p];
//              for(int q = 0;q < s;q++) {
//                  long a = X[q + s*(p+0)];
//                  long b = X[q + s*(p+m)];
//                  Y[q + s*(2*p+0)] = (a+b) % P;
//                  Y[q + s*(2*p+1)] = (a-b+P) * wp % P;
//              }
//          }
//          s *= 2;
//          eo = !eo;
//          long[] D = X; X = Y; Y = D;
//      }
//      long[] z = eo ? Y : X;
//      for(int q = 0;q < s;q++) {
//          long a = X[q + 0];
//          long b = X[q + s];
//          z[q+0] = (a+b) % P;
//          z[q+s] = (a-b+P) % P;
//      }
//  }
        private static long[] go(long[] src, int n, boolean inverse)
        {
            long[] dst = Arrays.copyOf(src, n);
            fft(dst, new long[n]);
            if(inverse){
                long in = invl(n);
                for(int i = 0;i < n;i++){
                    dst[i] = dst[i] * in % mod;
                }
            }
            return dst;
        }
        private static long pow(long a, long n) {
            //      a %= mod;
            long ret = 1;
            int x = 63 - Long.numberOfLeadingZeros(n);
            for (; x >= 0; x--) {
                ret = ret*ret % mod;
                if (n<<~x<0)ret = ret*a%mod;
            }
            return ret;
        }
        private static long invl(long a) {
            long b = mod;
            long p = 1, q = 0;
            while (b > 0) {
                long c = a / b;
                long d;
                d = a;
                a = b;
                b = d % b;
                d = p;
                p = q;
                q = d - c * q;
            }
            return p < 0 ? p + mod : p;
        }
    }
    public static long C(int n, int r, int mod, int[][] fif) {
        if (n < 0 || r < 0 || r > n) return 0;
        return (long) fif[0][n] * fif[1][r] % mod * fif[1][n - r] % mod;
    }
    public static int[][] enumFIF(int n, int mod) {
        int[] f = new int[n + 1];
        int[] invf = new int[n + 1];
        f[0] = 1;
        for (int i = 1; i <= n; i++) {
            f[i] = (int) ((long) f[i - 1] * i % mod);
        }
        long a = f[n];
        long b = mod;
        long p = 1, q = 0;
        while (b > 0) {
            long c = a / b;
            long d;
            d = a;
            a = b;
            b = d % b;
            d = p;
            p = q;
            q = d - c * q;
        }
        invf[n] = (int) (p < 0 ? p + mod : p);
        for (int i = n - 1; i >= 0; i--) {
            invf[i] = (int) ((long) invf[i + 1] * (i + 1) % mod);
        }
        return new int[][]{f, invf};
    }
    public static void main(String[] args) {
        new No2605().run();
    }
    public void run()
    {
        long S = System.currentTimeMillis();
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new FastWriter(System.out);
        solve();
        out.flush();
        long G = System.currentTimeMillis();
        tr(G-S+"ms");
        //      Thread t = new Thread(null, null, "~", Runtime.getRuntime().maxMemory()){
        //          @Override
        //          public void run() {
        //              long s = System.currentTimeMillis();
        //              solve();
        //              out.flush();
        //              if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
        //          }
        //      };
        //      t.start();
        //      t.join();
    }
    private boolean eof()
    {
        if(lenbuf == -1)return true;
        int lptr = ptrbuf;
        while(lptr < lenbuf)if(!isSpaceChar(inbuf[lptr++]))return false;
        try {
            is.mark(1000);
            while(true){
                int b = is.read();
                if(b == -1){
                    is.reset();
                    return true;
                }else if(!isSpaceChar(b)){
                    is.reset();
                    return false;
                }
            }
        } catch (IOException e) {
            return true;
        }
    }
    private final byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;
    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }
    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    //  private boolean isSpaceChar(int c) { return !(c >= 32 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }
    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }
    private char[][] nm(int n, int m)
    {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }
    private int[][] nmi(int n, int m)
    {
        int[][] map = new int[n][];
        for(int i = 0;i < n;i++)map[i] = na(m);
        return map;
    }
    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }
    private long[] nal(int n)
    {
        long[] a = new long[n];
        for(int i = 0;i < n;i++)a[i] = nl();
        return a;
    }
    private int ni()
    {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    public static class FastWriter
    {
        private static final int BUF_SIZE = 1<<13;
        private final byte[] buf = new byte[BUF_SIZE];
        private final OutputStream out;
        private int ptr = 0;
        private FastWriter(){out = null;}
        public FastWriter(OutputStream os)
        {
            this.out = os;
        }
        public FastWriter(String path)
        {
            try {
                this.out = new FileOutputStream(path);
            } catch (FileNotFoundException e) {
                throw new RuntimeException("FastWriter");
            }
        }
        public FastWriter write(byte b)
        {
            buf[ptr++] = b;
            if(ptr == BUF_SIZE)innerflush();
            return this;
        }
        public FastWriter write(char c)
        {
            return write((byte)c);
        }
        public FastWriter write(char[] s)
        {
            for(char c : s){
                buf[ptr++] = (byte)c;
                if(ptr == BUF_SIZE)innerflush();
            }
            return this;
        }
        public FastWriter write(String s)
        {
            s.chars().forEach(c -> {
                buf[ptr++] = (byte)c;
                if(ptr == BUF_SIZE)innerflush();
            });
            return this;
        }
        private static int countDigits(int l) {
            if (l >= 1000000000) return 10;
            if (l >= 100000000) return 9;
            if (l >= 10000000) return 8;
            if (l >= 1000000) return 7;
            if (l >= 100000) return 6;
            if (l >= 10000) return 5;
            if (l >= 1000) return 4;
            if (l >= 100) return 3;
            if (l >= 10) return 2;
            return 1;
        }
        public FastWriter write(int x)
        {
            if(x == Integer.MIN_VALUE){
                return write((long)x);
            }
            if(ptr + 12 >= BUF_SIZE)innerflush();
            if(x < 0){
                write((byte)'-');
                x = -x;
            }
            int d = countDigits(x);
            for(int i = ptr + d - 1;i >= ptr;i--){
                buf[i] = (byte)('0'+x%10);
                x /= 10;
            }
            ptr += d;
            return this;
        }
        private static int countDigits(long l) {
            if (l >= 1000000000000000000L) return 19;
            if (l >= 100000000000000000L) return 18;
            if (l >= 10000000000000000L) return 17;
            if (l >= 1000000000000000L) return 16;
            if (l >= 100000000000000L) return 15;
            if (l >= 10000000000000L) return 14;
            if (l >= 1000000000000L) return 13;
            if (l >= 100000000000L) return 12;
            if (l >= 10000000000L) return 11;
            if (l >= 1000000000L) return 10;
            if (l >= 100000000L) return 9;
            if (l >= 10000000L) return 8;
            if (l >= 1000000L) return 7;
            if (l >= 100000L) return 6;
            if (l >= 10000L) return 5;
            if (l >= 1000L) return 4;
            if (l >= 100L) return 3;
            if (l >= 10L) return 2;
            return 1;
        }
        public FastWriter write(long x)
        {
            if(x == Long.MIN_VALUE){
                return write("" + x);
            }
            if(ptr + 21 >= BUF_SIZE)innerflush();
            if(x < 0){
                write((byte)'-');
                x = -x;
            }
            int d = countDigits(x);
            for(int i = ptr + d - 1;i >= ptr;i--){
                buf[i] = (byte)('0'+x%10);
                x /= 10;
            }
            ptr += d;
            return this;
        }
        public FastWriter write(double x, int precision)
        {
            if(x < 0){
                write('-');
                x = -x;
            }
            x += Math.pow(10, -precision)/2;
            //      if(x < 0){ x = 0; }
            write((long)x).write(".");
            x -= (long)x;
            for(int i = 0;i < precision;i++){
                x *= 10;
                write((char)('0'+(int)x));
                x -= (int)x;
            }
            return this;
        }
        public FastWriter writeln(char c){ return write(c).writeln(); }
        public FastWriter writeln(int x){ return write(x).writeln(); }
        public FastWriter writeln(long x){ return write(x).writeln(); }
        public FastWriter writeln(double x, int precision){ return write(x, precision).writeln(); }
        public FastWriter write(int... xs)
        {
            boolean first = true;
            for(int x : xs) {
                if (!first) write(' ');
                first = false;
                write(x);
            }
            return this;
        }
        public FastWriter write(long... xs)
        {
            boolean first = true;
            for(long x : xs) {
                if (!first) write(' ');
                first = false;
                write(x);
            }
            return this;
        }
        public FastWriter write(IntUnaryOperator f, int... xs)
        {
            boolean first = true;
            for(int x : xs) {
                if (!first) write(' ');
                first = false;
                write(f.applyAsInt(x));
            }
            return this;
        }
        public FastWriter write(LongUnaryOperator f, long... xs)
        {
            boolean first = true;
            for(long x : xs) {
                if (!first) write(' ');
                first = false;
                write(f.applyAsLong(x));
            }
            return this;
        }
        public FastWriter writeln()
        {
            return write((byte)'\n');
        }
        public FastWriter writeln(int... xs) { return write(xs).writeln(); }
        public FastWriter writeln(long... xs) { return write(xs).writeln(); }
        public FastWriter writeln(IntUnaryOperator f, int... xs) { return write(f, xs).writeln(); }
        public FastWriter writeln(LongUnaryOperator f, long... xs) { return write(f, xs).writeln(); }
        public FastWriter writeln(char[] line) { return write(line).writeln(); }
        public FastWriter writeln(char[]... map) { for(char[] line : map)write(line).writeln();return this; }
        public FastWriter writeln(String s) { return write(s).writeln(); }
        private void innerflush()
        {
            try {
                out.write(buf, 0, ptr);
                ptr = 0;
            } catch (IOException e) {
                throw new RuntimeException("innerflush");
            }
        }
        public void flush()
        {
            innerflush();
            try {
                out.flush();
            } catch (IOException e) {
                throw new RuntimeException("flush");
            }
        }
        public FastWriter print(byte b) { return write(b); }
        public FastWriter print(char c) { return write(c); }
        public FastWriter print(char[] s) { return write(s); }
        public FastWriter print(String s) { return write(s); }
        public FastWriter print(int x) { return write(x); }
        public FastWriter print(long x) { return write(x); }
        public FastWriter print(double x, int precision) { return write(x, precision); }
        public FastWriter println(char c){ return writeln(c); }
        public FastWriter println(int x){ return writeln(x); }
        public FastWriter println(long x){ return writeln(x); }
        public FastWriter println(double x, int precision){ return writeln(x, precision); }
        public FastWriter print(int... xs) { return write(xs); }
        public FastWriter print(long... xs) { return write(xs); }
        public FastWriter print(IntUnaryOperator f, int... xs) { return write(f, xs); }
        public FastWriter print(LongUnaryOperator f, long... xs) { return write(f, xs); }
        public FastWriter println(int... xs) { return writeln(xs); }
        public FastWriter println(long... xs) { return writeln(xs); }
        public FastWriter println(IntUnaryOperator f, int... xs) { return writeln(f, xs); }
        public FastWriter println(LongUnaryOperator f, long... xs) { return writeln(f, xs); }
        public FastWriter println(char[] line) { return writeln(line); }
        public FastWriter println(char[]... map) { return writeln(map); }
        public FastWriter println(String s) { return writeln(s); }
        public FastWriter println() { return writeln(); }
    }
    public static void trnz(int... o)
    {
        for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
        System.out.println();
    }
    // print ids which are 1
    public static void trt(long... o)
    {
        Queue<Integer> stands = new ArrayDeque<>();
        for(int i = 0;i < o.length;i++){
            for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
        }
        System.out.println(stands);
    }
    public static void tf(boolean... r)
    {
        for(boolean x : r)System.out.print(x?'#':'.');
        System.out.println();
    }
    public static void tf(boolean[]... b)
    {
        for(boolean[] r : b) {
            for(boolean x : r)System.out.print(x?'#':'.');
            System.out.println();
        }
        System.out.println();
    }
    public void tf(long[]... b)
    {
        if(INPUT.length() != 0) {
            for (long[] r : b) {
                for (long x : r) {
                    for (int i = 0; i < 64; i++) {
                        System.out.print(x << ~i < 0 ? '#' : '.');
                    }
                }
                System.out.println();
            }
            System.out.println();
        }
    }
    public void tf(long... b)
    {
        if(INPUT.length() != 0) {
            for (long x : b) {
                for (int i = 0; i < 64; i++) {
                    System.out.print(x << ~i < 0 ? '#' : '.');
                }
            }
            System.out.println();
        }
    }
    private void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0