struct str_hash {//单hash
    static const int maxn = 3e5 + 5, p = 47, mod = 1e9 + 7;
    static int pw[maxn], pr[maxn];
    int h1[maxn], h2[maxn], len;

    str_hash() {
        if (pw[0] == 1) return;
        pw[0] = pr[0] = 1;
        int rev = qpow(p, mod - 2, mod);
        for (int i = 1; i < maxn; i++) {
            pw[i] = 1ll * pw[i - 1] * p % mod;
            pr[i] = 1ll * pr[i - 1] * rev % mod;
        }
    }

    void extend(char c) {
        len++;
        h1[len] = (1ll * h1[len - 1] * p + c) % mod;
        h2[len] = (h2[len - 1] + 1ll * c * pw[len - 1]) % mod;
    }

    void ini() { len = 0; }

    int query(int l, int r) { return (h1[r] + 1ll * h1[l - 1] * (mod - pw[r - l + 1])) % mod; }//注意没有下标检查
    int qurev(int l, int r) { return 1ll * (h2[r] - h2[l - 1] + mod) * pr[l - 1] % mod; }//注意没有下标检查
};

int str_hash::pw[maxn], str_hash::pr[maxn];


//双hash，双倍常数，1e6 的数据 nlgn的做法 1s的时限 不建议使用
typedef unsigned long long ull;

struct double_hash {
    static const ull maxn = 1e3 + 666, p = 26, mod1 = 1e9 + 7, mod2 = 1e9 + 9;
    static ull pw1[maxn], pw2[maxn];
    ull hash1[maxn], hash2[maxn], len;

    double_hash() {
        if (pw1[0] == 1)return;
        pw1[0] = pw2[0] = 1;
        for (ull i = 1; i < maxn; i++) {
            pw1[i] = pw1[i - 1] * p % mod1;
            pw2[i] = pw2[i - 1] * p % mod2;
        }
    }

    void build(char *s, ull _len) {
        len = _len;
        for (ull i = 1; i <= len; i++) {
            hash1[i] = (hash1[i - 1] * p + s[i] - 'a') % mod1;//无边界
            hash2[i] = (hash2[i - 1] * p + s[i] - 'a') % mod2;//same
        }
    }

    ull query1(ull l, ull r) { return (hash1[r] - hash1[l - 1] * pw1[r - l + 1] % mod1 + mod1) % mod1; }

    ull query2(ull l, ull r) { return (hash2[r] - hash2[l - 1] * pw2[r - l + 1] % mod2 + mod2) % mod2; }

    ull query(ull l, ull r) { return query1(l, r) * mod2 + query2(l, r); }//注意没有下标检查
} hash_a, hash_b;

ull double_hash::pw1[maxn], double_hash::pw2[maxn];

inline void GetNext(char *s) {
    int l = strlen(s), t;
    next[0] = -1;
    for (int i = 1; i < l; ++i) {
        t = next[i - 1];
        while (s[t + 1] != s[i] && t >= 0)
            t = next[t];
        if (s[t + 1] == s[i])
            next[i] = t + 1;
        else
            next[i] = -1;
    }
}

inline void KMP(char *s1, char *s2) {
    ans.clear();
    GetNext(s2);//预处理next数组
    int len_1 = strlen(s1);
    int len_2 = strlen(s2);
    int i = 0, j = 0;
    while (j < len_1) {
        if (s2[i] == s1[j]) {
            ++i;
            ++j;
            if (i == len_2) {
                ans.push_back(j - len_2 + 1);
                i = next[i - 1] + 1;
            }
        } else {
            if (i == 0)
                j++;
            else
                i = next[i - 1] + 1;
        }
    }
}

const double eps=1e-8;
struct MCMF{
    static const int maxn=200,maxm=40000;
    struct star{int v,nex;double c,w;} edge[maxm<<1];
    int head[maxn],cnt,n;
    int inq[maxn],pre[maxn];
    double dist[maxn];

    void ini(int n){
        cnt=-1;this->n=n;
        for(int i=0;i<=n;i++) head[i]=-1;
    }
    void add_star(int u, int v, double c, double w){
        //cout<<"     "<<u<<" "<<v<<" "<<c<<" "<<w<<endl;
        edge[++cnt]=star{v,head[u],c, w}; head[u]=cnt;
        edge[++cnt]=star{u,head[v],0,-w}; head[v]=cnt;
    }
    void minCostMaxFlow(int s, int t,double&flow,double&cost){
        flow=cost=0;
        while(true){
            for(int i=0;i<=n;i++) dist[i]=1e9;
            queue<int>que; que.push(s);
            inq[s]=1; dist[s]=0;

            while(!que.empty()){
                int u=que.front();
                que.pop(); inq[u]=0;
                for(int i=head[u];~i;i=edge[i].nex){
                    int v=edge[i].v;
                    double c=edge[i].c,w=edge[i].w;
                    if(c>eps&&dist[v]>dist[u]+w+eps){
                    // if(c>0&&dist[v]>dist[u]+w){
                        dist[v]=dist[u]+w;
                        pre[v]=i;
                        if(!inq[v]) que.push(v);
                        inq[v]=1;
                    }
                }
            }
            if(dist[t]==1e9) return ;
            double addf=1e9;
            for(int x=t;x!=s;x=edge[pre[x]^1].v) addf=min(addf,edge[pre[x]].c);
            for(int x=t;x!=s;x=edge[pre[x]^1].v){
                edge[pre[x]].c-=addf;
                edge[pre[x]^1].c+=addf;
            }
            flow+=addf;
            cost+=dist[t]*addf;
        }
    }
} g;