mix

//polya burnside定理 http://blog.csdn.net/liangzhaoyang1/article/details/72639208
//原题ASIA qingdao  https://nanti.jisuanke.com/t/18515
#include <iostream>
#include <map>
#include <algorithm>
#include <cstring>

using namespace std;

map<string, bool> vis;
int tot;
const int LEN = 16;
int oo[3][LEN] = {//翻转 旋转 扭转
    {0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5, 12, 13, 15, 14},
    {13, 12, 4, 2, 5, 3, 15, 14, 9, 11, 8, 10, 6, 7, 0, 1},
    {1, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 14, 15, 12, 13}
};
bool cir[LEN+5];
char sss[LEN+5];
int cnts[LEN+5]={0};

int cnt(string &s){
    int res = 0;
    memset(cir,0,sizeof(cir));
    int f;
    for(int i = 0; i < LEN; i++){
        if(!cir[i]){
            cir[i] = true;
            f = i;
            while(!cir[f = s[f]-'A']){
                cir[f] = true;
            }
            res++;
        }
    }
    return res;
}

void bfs(string s){
    if(vis[s]) return;
    tot++;
    vis[s] = true;
    cnts[cnt(s)]++;
    string ss = s;
    for(int i = 0; i < 3; i++){
        for(int k = 0; k < LEN; k++){
            s[k] = ss[oo[i][k]];
        }
        bfs(s);
    }
}

int main(){
    tot = 0;
    for(int i = 0; i < LEN; i++)
        sss[i] = i+'A';
    sss[LEN] = '';
    string s = sss;
    bfs(s);
    int n;
    while(cin >> n){
        long long ans = 0;
        long long p = 1;
        for(int i = 1; i <= LEN; i++){
            p *= n;
            ans += cnts[i]*p;
        }
        ans /= tot;
        cout << ans << endl;
    }
    return 0;
}

//polya hdu3923
// https://www.cnblogs.com/lxjshuju/p/6824210.html
#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod=1000000007;

LL gcd(LL a, LL b){
    return b==0?a:gcd(b,a%b);
}

LL power(LL p, LL n){
    LL ans = 1;
    while(n){
        if(n&1)
            ans = ans*p%mod;
        p = p*p%mod;
        n/=2;
    }
    return ans;
}

LL exgcd(LL a, LL b, LL &x, LL &y){
    if(!b){
        x = 1;
        y = 0;
        return a;
    }
    LL d = exgcd(b,a%b,x,y);
    LL t = x;
    x = y;
    y = t - a/b*y;
    return d;
}

int main(){
    int T;
    cin >> T;
    int q = 0;
    while(T--){
        LL ans = 0;
        LL n,m;
        cin >> n >> m;
        for(LL i = 1; i <= m; i++){
            ans += power(n,gcd(m,i));
            ans%=mod;
        }
        if(m&1)
            ans += (m*power(n,m/2+1))%mod;
        else
            ans += ((m/2*power(n,m/2+1))%mod+(m/2*power(n,m/2))%mod);
        ans %= mod;
        LL x, y;
        exgcd(2*m,mod,x,y);
        //x=power(2*n,mod-2)%mod;//另外一种,费马小定理
        x = (x+mod)%mod;
        cout << "Case #" << ++q <<": "<< ans*x%mod << endl;
    }
    return 0;
}

//poj3070
//矩阵快速幂
//http://blog.csdn.net/wust_zzwh/article/details/52058209
//https://www.cnblogs.com/Commence/p/3976132.html
#include <iostream>
using namespace std;

struct mat{
    int D[3][3];
};
mat d;

mat xx(mat x, mat y){
    mat z;
    for(int k = 0; k < 2; k++)
        for(int i = 0; i < 2; i++)
            z.D[i][k] = 0;
    for(int k = 0; k < 2; k++){
        for(int i = 0; i < 2; i++){
                for(int j = 0; j < 2; j++){
                    z.D[i][j] += x.D[i][k] * y.D[k][j];
                    z.D[i][j] %= 10000;
                }
        }
    }
    return z;
}

int power(mat a, int b){
    mat ans;
    for(int k = 0; k < 2; k++)
        for(int i = 0; i < 2; i++)
            ans.D[i][k] = (i==k);
    while(b){
        if(b&1)
            ans = xx(ans,a);
        a = xx(a,a);
        b/=2;
    }
    return ans.D[0][1];
}

int solve(int t){
    d.D[0][0] = d.D[1][0] = d.D[0][1] = 1;
    d.D[1][1] = 0;
    int ans = 0;
    ans = power(d,t);
    return ans;
}

int main(){
    int k;
    while(cin >> k && k>=0){
        cout << solve(k) << endl;
    }
     return 0;
}

//poj3233  矩阵快速幂
//https://www.cnblogs.com/hadilo/p/5903514.html
#include <stdio.h>

struct mat{
    int dd[70][70];
}D,d;

int n, k, m;

mat xx(mat x, mat y){
    mat c;
    for(int k = 0; k < n; k++)
        for(int i = 0; i < n; i++)
            c.dd[k][i] = 0;
    for(int k = 0; k < n; k++){
        for(int i = 0; i < n; i++){
            if(x.dd[i][k] <= 0)
                continue;
            for(int j = 0; j < n; j++){
                if(y.dd[k][j] <= 0)
                    continue;
                c.dd[i][j] += x.dd[i][k] * y.dd[k][j];
                c.dd[i][j] %= m;
            }
        }
    }
    return c;
}

void power(mat a, int b){
    while(b){
        if(b&1){
            d = xx(d,a);
        }
        a = xx(a,a);
        b/=2;
    }
}

int main(){
    while(~scanf("%d%d%d",&n,&k,&m)){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++)
                scanf("%d",&D.dd[i][j]);
            D.dd[i][i+n] = D.dd[i+n][i+n] = d.dd[i][i] = d.dd[i+n][i+n] = 1;
        }
        n*=2;
        k++;
        power(D,k);
        n/=2;
        for(int i = 0; i < n; i++)
            d.dd[i][i+n]= (d.dd[i][i+n]-1+m)%m;
        for(int i = 0; i < n; i++){
            for(int k = 0; k < n; k++){
                if(k!=0)
                    printf(" ");
                printf("%d", d.dd[i][k+n]);
            }
            printf("
");
        }
    }
    return 0;
}

//快速幂 hdu2276
//https://www.cnblogs.com/zzqc/p/7152684.html
//注意左乘和右乘矩阵，矩阵的方向，矩阵的初始化
#include <stdio.h>
#include <cstring>

struct mat{
    int d[102][102];
};
int len;
int t[102];
int n;

mat xx(mat x, mat y){
    mat z;
    for(int k = 0; k < len; k++)
        for(int i = 0; i < len; i++)
            z.d[i][k] = 0;
    for(int k = 0; k < len; k++){
        for(int i = 0; i < len; i++){
                for(int j = 0; j < len; j++){
                    z.d[i][j] += x.d[i][k] * y.d[k][j];
                    z.d[i][j] %= 2;
                }
        }
    }
    return z;
}

mat power(mat x, int y){
    mat ans;
    for(int k = 0; k < len; k++)
        for(int i = 0; i < len; i++)
            ans.d[i][k] = (i==k);
    while(y){
        if(y&1){
            ans = xx(ans,x);
        }
        x = xx(x,x);
        y/=2;
    }
    return ans;
}

void solve(){
    mat a;
    for(int k = 0; k < len; k++)
        for(int i = 0; i < len; i++)
            a.d[i][k] = 0;
    a.d[len-1][0] = a.d[0][0] = 1;
    for(int i = 1; i < len; i++){
        a.d[i-1][i] = a.d[i][i] = 1;
    }
    a = power(a,n);
    for(int i = 0; i < len; i++){
        int z = 0;
        for(int k = 0; k < len; k++){
            z += t[k] * a.d[k][i];
            z %= 2;
        }
        printf("%d", z);
    }printf("
");
}

int main(){
    while(~scanf("%d",&n)){
        char s[102];
        scanf("%s",s);
        len = strlen(s);
        for(int i = 0; i < len; i++)
            t[i] = s[i] - '0';
        solve();
    }
    return 0;
}

//欧拉回路 Hdu3018
//http://www.cnblogs.com/buptLizer/archive/2012/04/15/2450297.html
//
#include <iostream>
using namespace std;

int deg[100010];
int n,m;
int f[100010],odd[100010],cir[100010];
bool used[100010];

void init(){
    for(int i = 0; i <= n; i++){
        deg[i] = 0;
        used[i] = false;
        odd[i] = 0;
        f[i] = i;
        cir[i] = 0;
    }
}

int find(int a){
    return f[a]==a?a:f[a] = find(f[a]);
}

void unite(int a, int b){
    int a1 = find(a), b1 = find(b);
    if(a1==b1)
        return;
    f[a1] = b1;
}

int main(){
    while(cin >> n >> m){
        init();
        int a,b;
        for(int i = 0; i < m; i++){
            cin >> a >> b;
            deg[a]++;
            deg[b]++;
            unite(a,b);
        }
        int cnt = 0;
        for(int i = 1; i <= n; i++){//注意是从1开始
            int t = find(i);
            if(!used[t]){
                used[t] = true;
                cir[cnt++] = t;
            }
            if(deg[i]%2==1)
                odd[t]++;
        }

        int ans = 0;
        for(int i = 0; i < cnt; i++){
            if(deg[cir[i]]==0)
                continue;
            if(odd[cir[i]]==0)
                ans++;
            else
                ans += odd[cir[i]]/2;
        }
        cout << ans << endl;
    }
    return 0;
}

//poj2230 欧拉回路
#include <stdio.h>
#include <algorithm>
#include <cstring>
using namespace std;

struct Edge{
    int to, next;
}edge[100005];

int head[10005],used[100005],n,m,cnt;

void add(int x, int y){
    edge[cnt].to = y;
    edge[cnt].next = head[x];
    head[x] = cnt++;
}

void dfs(int u){
    for(int i = head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(!used[i]){
            used[i] = 1;
            dfs(v);
        }
    }
    printf("%d
", u);
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        cnt = 1;
        memset(head,-1,sizeof(head));
        memset(used,0,sizeof(used));
        int x, y;
        while(m--){
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }
        dfs(1);
    }
    return 0;
}

//poj1386 欧拉回路
//http://www.cnblogs.com/buptLizer/archive/2012/04/15/2450297.html
#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;

int in[30],out[30];
int f[30];
int _rank[30];
bool used[30];
int n;

void init(){
    for(int i = 0; i < 30; i++){
        _rank[i] = 1;
        f[i] = -1;
        in[i] = 0;
        out[i] = 0;
        used[i] = false;
    }
}

int find(int a){
    if(f[a]>=0)
        return f[a] = find(f[a]);
    return a;
}

void unite(int x, int y){
    int a = find(x), b = find(y);
    if(a==b)
        return;
    if(_rank[a] < _rank[b]){
        f[a] = b;
    }else{
        f[b] = a;
        if(_rank[a]==_rank[b])
            _rank[a]++;
    }
    return;
}

int main(){
    int t;
    cin >> t;
    while(t--){
        init();
        cin >> n;
        for(int i = 0; i < n; i++){
            char a[1010];
            scanf("%s",a);
            int len = strlen(a);
            int x = a[0] - 'a';
            = used[y] = true;
            out[x]++;
            in[y]++;
            unite(x,y);
        }
        int cir = 0;
        for(int i = 0; i < 30; i++){
            if(used[i] && f[i]<0){
                cir++;
            }
        }
        if(cir > 1){
            cout << "The door cannot be opened." <<endl;
            continue;
        }
        int j = 0, k = 0, i;
        for(i = 0; i < 30; i++){
            if(used[i] && in[i]!=out[i]){
                if(in[i]-out[i]==1)
                    j++;
                else if(out[i]-in[i]==1)
                    k++;
                else break;
            }
        }
        if(i<30)
            cout << "The door cannot be opened." <<endl;
        else if(!(j+k) || (j==1&&k==1))
            cout << "Ordering is possible." <<endl;
        else
            cout << "The door cannot be opened." <<endl;
    }
    return 0;
}

//Poj2337 欧拉回路
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <math.h>
#include <string.h>

using namespace std;

struct E{
    int to,next,index;
    bool flag;
}edge[2010];

int cnt;
int head[30], in[30], out[30];
string s[1010];
int tot, start;
int ans[1010];

void add(int a, int b, int index){
    edge[tot].to = b;
    edge[tot].next = head[a];
    edge[tot].flag = false;
    edge[tot].index = index;
    head[a] = tot++;
}

void dfs(int t){
    for(int i = head[t]; i!=-1; i = edge[i].next){
        if(!edge[i].flag){
            edge[i].flag = true;
            dfs(edge[i].to);
            ans[cnt++] = edge[i].index;
        }
    }
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        for(int i = 0; i < n; i++){
            cin >> s[i];
        }
        sort(s,s+n);
        memset(head,-1,sizeof(head));
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        tot = 0;
        start = 0x3f;
        for(int i = n-1; i >= 0; i--){//因为是邻接表头插法，所以从字典序最大的开始加
            int len = s[i].length();
            int l = s[i][0] - 'a';
            int r = s[i][len-1] - 'a';
            add(l,r,i);
            in[r]++;
            out[l]++;
            if(l<start)
                start = l;
            if(r<start)
                start = r;//起点选择最小的
        }
        int q = 0, w = 0;
        for(int i = 0; i < 30; i++){
            if(out[i]-in[i] == 1){
                q++;
                start = i;//如果有出度>入度+1的，为起点
            }
            else if(in[i]-out[i] == 1)
                w++;
            else if(in[i]!=out[i])
                q=999;
        }
        if(!((q==0&&w==0) || (q==1&&w==1))){
            printf("***
");
            continue;
        }
        cnt = 0;
        dfs(start);
        if(cnt!=n){
            printf("***
");
            continue;
        }
        for(int i = cnt-1; i>=0; i--){
            cout << s[ans[i]];
            if(i==0)
                printf("
");
            else
                printf(".");
        }
    }
    return 0;
}

//Hdu1800 ELFhash
//https://www.cnblogs.com/blvt/p/7953641.html
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <math.h>
using namespace std;

int ans;
int ha[1010101],num[1010101];
int mod = 1010101;

int ELFhash(char *s){
     unsigned int p = 0, q;
     while(*s){
         p = (p << 4) + *s++;//h左移4位，当前字符占8位，再加到h中进行杂糅
         if((q = p & 0x70000000) != 0){ //取h最左四位的值，若均为0，则括号中执行与否没区别，故不执行
             p ^= q>>24;//用p28-31位的值对p的5~8位进行杂糅
             p &= ~q;//清空p的最左四位
         }
     }
    return p & 0x7fffffff;
    //return p;//因为每次都清空了28~31位，最后结果最多也就是28位二进制整数，不会超int
}

void hash_table(char *s){
    int k = ELFhash(s);
    int t = k % mod;
    /*
    int cnt1 = 1, cnt2 = 0;
    while(ha[t] != k && ha[t] != -1){
        t = (t + cnt1*cnt1 - cnt2*cnt2)%mod;
        cnt1++,cnt2++;//平方探测法
    }
    */
    while(ha[t] != k && ha[t] != -1){
        t = (t+1)%mod;
    }
    if(ha[t] == -1){
        ha[t] = k;
        num[t] = 1;
    }else{
        ans = max(ans, ++num[t]);
    }
}

int main(){
    int n;
    while(~scanf("%d",&n)){
        memset(ha,-1,sizeof(ha));
        memset(num,0,sizeof(num));
        ans = 1;
        for(int i = 0; i < n; i++){
            char s[32];
            scanf("%s",s);
            int k = 0;
            while(s[k] == '0')
                k++;
            hash_table(s+k);
        }
        printf("%d
", ans);
    }
    return 0;
}

//Hdu2444 二分图匹配
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>

#define MAXN 205
using namespace std;

vector<int> g[MAXN];
int l[MAXN];
bool used[MAXN];
int m, n;
int ans;

bool judge(int v){
    for(int i = 0; i < g[v].size(); i++){
        int z= g[v][i];
        if(l[z] == 0){
            l[z] = !l[v];//1和-1两种标记，表示属于两个集合
            used[z] = true;
            if(!judge(z))
                return false;
        }else if(l[z] == l[v])
            return false;
    }
    return true;
}

bool tu(){
    memset(used,false,sizeof(used));
    memset(l,0,sizeof(l));//注意这里是0
    for(int i = 1; i <= n; i++){
        if(g[i].size() && !used[i]){
            used[i] = true;
            memset(l,0,sizeof(l));
            l[i] = 1;//第一个点标记为1
            if(!judge(i))
                return false;
        }
    }
    return true;
}

bool dfs(int v){
    for(int i = 0; i < g[v].size(); i++){
        int z = g[v][i];
        if(!used[z]){
            used[z] = true;
            if(l[z]==-1 || dfs(l[z])){
                l[z] = v;
                l[v] = z;
                return true;
            }
        }
    }
    return false;
}

void solve(){
    memset(l,-1,sizeof(l));
    for(int i = 1; i <= n; i++){
        if(l[i]==-1){//l[i]表示i邻接l[i]边
            memset(used,false,sizeof(used));
            if(dfs(i))
                ans++;
        }
    }
}

int main(){
    while(cin >> n >> m){
        for (int i = 0; i < MAXN; i++)
            g[i].clear();
        for(int i = 0; i < m; i++){
            int a, b;
            cin >> a >> b;
            g[b].push_back(a);
            g[a].push_back(b);
        }
        if(!tu())//判断是否为二分图
            printf("No
"); 
        else{
            ans = 0;
            solve();
            printf("%d
",ans);   
        }
    }
    return 0;
}

//Hdu2255 KM算法
//https://www.cnblogs.com/wenruo/p/5264235.html
#include <stdio.h>
#include <cstring>
#include <algorithm>
#define INF 0x3f3f3f3f
#define N 302

using namespace std;

int n;
int g[N][N];
int exl[N], exr[N];//好感度
bool visl[N], visr[N];//是否被访问
int match[N];//match[r]=i,i是r的匹配边
int least[N];//r可以被匹配的最低好感度

bool dfs(int v){
    visl[v] = true;
    for(int i = 0; i < n; i++){
        if(visr[i])
            continue;
        int gg = exl[v]+exr[i]-g[v][i];
        if(gg == 0){
            visr[i] = true;
            if(match[i]==-1 || dfs(match[i])){
                match[i] = v;
                return true;
            }
        }else{
            least[i] = min(gg, least[i]);
        }
    }
    return false;
}

int km(){
    memset(match, -1, sizeof(match));
    memset(exr, 0, sizeof(exr));

    for(int i = 0; i < n; i++){//初始好感度是最大的lr
        exl[i] = g[i][0];
        for(int j = 1; j < n; j++){
            exl[i] = max(exl[i], g[i][j]);
        }
    }

    for(int i = 0; i < n; i++){
        for(int k = 0; k < n; k++)
            least[k] = INF;//r可以被匹配的最低好感度

        while(1){//如果找不到就降低期望值，直到找到为止
            memset(visl,false,sizeof(visl));
            memset(visr,false,sizeof(visr));
            if(dfs(i))//匹配  退出
                break;

            // 如果不能找到 就降低期望值
            int d = INF;
            for(int j = 0; j < n; j++){
                if(!visr[j])
                    d = min(d, least[j]);// 最小可降低的期望值
            }
            for(int j = 0; j < n; j++){
                if(visl[j])//所有访问过的女生降低期望值
                    exl[j] -= d;
                if(visr[j])//所有访问过的男生增加期望值(膨胀)
                    exr[j] += d;
                if(!visr[j])//// 没有访问过的boy 因为girl们的期望值降低，距离得到女生倾心又进了一步！
                    least[j] -= d;
            }
        }
    }
    int ans = 0;
    for(int h = 0; h < n; h++){
        ans += g[match[h]][h];
    }
    return ans;
}

int main(){
    while(~scanf("%d",&n)){
        for(int i = 0; i < n; i++){
            for(int k = 0; k < n; k++)
                scanf("%d", &g[i][k]);
        }
        printf("%d
", km());
    }
    return 0;
}

//Poj3020 二分图-最短路径覆盖
//http://blog.csdn.net/lyy289065406/article/details/6647040
//建图是关键，其他常规
//无向二分图的最小路径覆盖 = 顶点数 – 最大二分匹配数
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#define N 402
using namespace std;

int cnt;
int tu[N][N];
int used[N];
vector<int> g[N];
int x1[] = {0,1,-1,0};
int y1[] = {1,0,0,-1};
int l[N];

bool dfs(int v){
    for(int i = 0; i < g[v].size(); i++){
        int z = g[v][i];
        if(!used[z]){
            used[z] = true;
            if(l[z]==-1 || dfs(l[z])){
                l[z] = v;
                return true;
            }
        }
    }
    return false;
}

int solve(){
    int ans = 0;
    memset(l,-1,sizeof(l));
    for(int i = 1; i <= cnt; i++){
        memset(used,false,sizeof(used));
        if(dfs(i))
            ans++;
    }
    return ans/2;
}

int main(){
    int t;
    cin >> t;
    while(t--){
        cnt = 0;
        int h,w;
        cin >> h >> w;
        for(int i = 0; i < N; i++)
            g[i].clear();
        for(int i = 0; i < h; i++){
            for(int k = 0; k < w; k++){
                char q;
                cin >> q;
                if(q=='*')
                    tu[i][k] = ++cnt;
                else
                    tu[i][k] = -1;
            }
        }
        for(int i = 0; i < h; i++)
            for(int k = 0; k < w; k++){
                if(tu[i][k]!=-1){
                    for(int j = 0; j < 4; j++){
                        int xx = i+x1[j], yy = k+y1[j];
                        if(xx>=0 && yy>=0 && xx<h && yy<w && tu[xx][yy]!=-1){
                            g[tu[i][k]].push_back(tu[xx][yy]);
                        }
                    }
                }
            }
        cout << cnt-solve() << endl;
    }
    return 0;
}

//Poj3686 二分图的最佳完美匹配
//http://blog.csdn.net/sixdaycoder/article/details/47720471
#include <iostream>
#include <algorithm>
#include <cstring>
#include <stdio.h>

#define N 52
#define INF 0x3f3f3f3f
using namespace std;

int g[N][N];
int c[N][N*N];
int n, m;
int exl[N], exr[N*N];
bool visl[N], visr[N*N];
int match[N*N];
int least[N*N];

bool dfs(int v){
    visl[v] = true;
    for(int i = 1; i <= m; i++){
        if(visr[i])
            continue;
        int gg = exl[v]+exr[i]-c[v][i];
        if(gg==0){
            visr[i] = true;
            if(match[i]==-1 || dfs(match[i])){
                match[i] = v;
                return true;
            }
        }else
            least[i] = min(gg,least[i]);
    }
    return false;
}

int km(){
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            least[j] = INF;
        }
        while(1){
            memset(visl,false,sizeof(visl));
            memset(visr,false,sizeof(visr));
            if(dfs(i)){
                break;
            }

            int d = INF;
            for(int j = 1; j <= m; j++){
                if(!visr[j])
                    d = min(d, least[j]);
            }

            for(int j = 1; j <= n; j++)
                if(visl[j])
                    exl[j] -= d;
            for(int j = 1; j <= m; j++){
                if(visr[j])
                    exr[j] += d;
                else
                    least[j] -= d;
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= m; i++)
        if(match[i]!=-1)
            ans += c[match[i]][i];
    return ans;
}


int main(){
    int t;
    cin >> t;
    while(t--){
        memset(g,0,sizeof(g));
        memset(c,0,sizeof(c));
        memset(match, -1, sizeof(match));
        memset(exr, 0, sizeof(exr));
        memset(exl, 0, sizeof(exl));

        cin >> n >> m;
        for(int i = 1; i <= n; i++)
            for(int k = 1 ; k <= m; k++){
                cin>> g[i][k];
            }

        for(int i = 1; i <= n; i++){
            for(int k = 1 ; k <= n; k++){
                for(int j = 1; j <= m; j++){
                    c[i][(k-1)*m+j] = -g[i][j]*k;
                }
            }
        }
        m*=n;
        printf("%.6f
",-1.0*km()/n);
    }
    return 0;
}

//Poj3713 
#include <iostream>
#include <algorithm>
#include <cstring>
#include <stdio.h>
#include <vector>

#define N 520
using namespace std;

vector<int> g[N];
bool has[N], vis[N];
int match[N];
int n, m;

bool dfs(int u, int v){
    for(int i = 0; i < g[u].size(); i++){
        int t = g[u][i];
        if(t==v){
            if(has[u])
                continue;
            has[u] = true;
            return true;
        }
        if(vis[t])
            continue;
        vis[t] = true;
        if(dfs(match[t],v)){
            match[t] = u;
            return true;
        }
    }
    return false;
}

bool flow(int u,int v){
    memset(has,0,sizeof(has));
    for(int i = 0; i < n; i++){
        match[i] = i;
    }
    for(int i = 0; i < 3; i++){
        memset(vis,false,sizeof(vis));
        if(!dfs(u,v))
            return false;
    }
    return true;
}

bool doit(){
    for(int i = 1; i < n; i++){
        if(!flow(0,i))
            return false;
    }
    return true;
}

int main(){
    while(cin >> n >> m && n && m){
        for (int i = 0;i < n;++i) {
            g[i].clear();
            g[i].push_back(i);
        }
        for(int i = 0; i < m; i++){
            int a, b;
            cin >> a >> b;
            g[a].push_back(b);
            g[b].push_back(a);
        }
        if(!doit())
            cout << "NO" << endl;
        else
            cout << "YES" << endl;
    }
    return 0;
}

/*
Hdu2588 
求k使gcd(k,n)>=m，设a = gcd(k,n) >= m
则 k=a*d,n=a*b(k属于1~n，d与b互质,d<b)
则需要枚举1-n求k，而因为k与n已知，所以a已知，相当于枚举d，因为d b互质,d<b,所以满足(k=a*d && gcd(k,n)>=m)的d的个数等于φ(b)
所以只枚举1-n求φ(b)

for(a = 1 to n)
    if(n/a没有余数)//n=a*b  那么n/a就是b了
        if(a>=m) //那么n/a就是b了
        if(n/a>=m)//n=a*b  枚举大于根号n的一半，那么n/(n/a)就是b了
*/
#include <iostream>
using namespace std;

int n;

int euler(int n){
    int res = n;
    for(int i = 2; i*i <= n; i++){
        if(n%i==0){
            res = res/i*(i-1);
            while(n%i==0)
                n/=i;
        }
    }
    if(n>1)
        res -= res/n;
    return res;
}

int main(){
    int t;
    cin >> t;
    while(t--){
        int n, m;
        cin >> n >> m;
        int ans = 0;
        for(int i = 1; i*i <= n; i++){
            if(n%i==0){
                if(i>=m)
                    ans+=euler(n/i);
                if(n/i>=m && i*i!=n)
                    ans+=euler(i);
            }
        }
        cout << ans << endl;
    }
    return 0;
}

//Poj3696 强行ac,不知所云
//https://www.cnblogs.com/chenxiwenruo/p/3569146.html
//a*b=c*d  a与c互质时，b整除c，d整除a
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;

typedef long long LL;

LL gcd(LL a, LL b){
    return b?gcd(b,a%b):a;
}

LL eular(LL n){
    LL ans = n;
    for(LL i = 2; i*i <= n; i++){
        if(n%i==0){
            ans = ans/i*(i-1);
            while(n%i==0)
                n/=i;
        }
    }
    if(n>1)
        ans -= ans/n;
    return ans;
}

LL mul(LL x, LL y, LL m){
    LL ans = 0;
    while(y){
        if(y&1)
            ans = (ans+x)%m;
        x = x*2%m;
        y>>=1;
    }
    return ans;
}

LL powmod(LL x, LL y, LL m){
    LL ans = 1;
    while(y){
        if(y&1)
            ans = mul(ans,x,m);
        x = mul(x,x,m);
        y>>=1;
    }
    return ans;
}

int main(){
    int t = 1;
    LL L;
    while(cin >> L){
        if(L == 0) break;
        LL q = 1LL*9*L/gcd(8,L);
        LL d = gcd(10,q);
        if(d != 1){
            cout << "Case " << t++ << ": 0"<< endl;
        }else{
            LL phi = eular(q);
            LL ans = phi;
            LL m = sqrt((double)phi);
            bool flag = false;
            for(LL i = 1; i <= m; i++){
                if(phi%i==0 && powmod(10,i,q)==1){
                    ans = i;
                    flag = true;
                    break;
                }
            }
            if(!flag){
                for(LL i = m; i >= 2; i--){
                    if(phi%i==0 && powmod(10,phi/i,q)==1){
                        ans = phi/i;
                        break;
                    }
                }
            }
            cout << "Case "<< t++ << ": " << ans <<endl;
        }
    }
    return 0;
}

//Poj2891 中国剩余定理/线性同余方程组（模数不一定互质情况）
//http://blog.csdn.net/acdreamers/article/details/8050018
//http://blog.csdn.net/zmh964685331/article/details/50527894
#include <iostream>
#include <algorithm>
#include <cstring>
#include <stdio.h>

using namespace std;
typedef long long ll;
ll n;
int m[1000002], a[1000002];

ll exgcd(ll a, ll b, ll &x, ll &y){
    if(b==0){
        x = 1;
        y = 0;
        return a;
    }
    ll ans = exgcd(b,a%b,y,x);
    y -= a/b*x;
    return ans;
}

ll gcd(ll a, ll b){
    return b?gcd(b,a%b):a;
}

ll china(ll n){
    ll m1=m[0],a1=a[0],m2,a2,k1,k2,x0,mgcd,c;
    for(int i = 1; i < n; i++){
        m2 = m[i], a2 = a[i];
        c = a2-a1;
        mgcd=exgcd(m1,m2,k1,k2);
        if(c%mgcd){
            return -1;
        }
        x0 = c/mgcd*k1;
        ll t = m2/mgcd;
        x0 = (x0%t+t)%t;
        a1+=m1*x0;
        m1*=m2/mgcd;
    }
    return a1;
}

int main(){
    while(cin >> n){
        for(int i = 0; i < n; i++){
            cin >> m[i];cin >> a[i];
        }
        ll ans = china(n);
        ll sum = 0;
        cout << ans <<endl;
    }
    return 0;
}

//Hysbz1588 Splay模板
//模板https://files.cnblogs.com/files/tony-/Splay%E5%9F%BA%E7%A1%80_%E6%A8%A1%E6%9D%BF.pdf
#include <iostream>
#include <cmath>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define N 33000

using namespace std;
int tot, rt;
int ch[N][2], pre[N], key[N], rev[N];
//    儿子     父亲 节点值  翻转标记

void init(int n){
    rt = tot = 0;
    l(rt)=r(rt)=pre[rt]=key[rt]=0;
}

void newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    key[u] = val;
}

void rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];//父亲的儿子位置更新
    pre[ch[u][dir]] = fa;//更新原来的儿子的父亲
    if(pre[fa])//如果父节点不是根节点，则更新爷爷的儿子
        ch[pre[fa]][ch[pre[fa]][1]==fa]=u;
    pre[u] = pre[fa];//更新u的父亲
    ch[u][dir] = fa;//更新u的儿子的父亲    
    pre[fa] = u;//更新u的父亲的父亲
}

void splay(int u, int goal){//将节点u旋转为goal的儿子
    int fa, kind;
    while(pre[u] != goal){
        if(pre[pre[u]] == goal){//爷爷是目标，只旋转一次
            rotate(u, l(pre[u])==u);
        }else{
            fa = pre[u];
            int dir = l(pre[fa])==fa;
            if(ch[fa][dir]==u){//一左一右，两次方向相反的旋转
                rotate(u,!dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa,dir);
                rotate(u,dir);
            }
        }
    }
    if(goal==0)
        rt = u;
}

int insert(int val){//插入val，将此节点旋转为根
    if(!rt)
        newnode(rt,0,val);
    else{
        int x = rt;
        while(ch[x][key[x]<val]){//根的值小于val
            if(key[x] == val){
                splay(x,0);
                return 0;
            }
            x = ch[x][key[x]<val];//val>当前节点 进入右儿子，反之xxxx
        }
        newnode(ch[x][key[x]<val], x, val);
        splay(ch[x][key[x]<val], 0);
    }
    return 1;
}

int getpre(int u){
    u = l(u);
    while(r(u)){
        u=r(u);
    }
    return u;
}

int getnxt(int u){
    u = r(u);
    while(l(u)){
        u=l(u);
    }
    return u;
}

int main(){
    int a;
    int n;
    cin >> n;
    init(n);
    insert(-0x3f3f3f3f);//插入两个无限大小的点，才可以比较大小
    insert(0x3f3f3f3f);
    cin >> a;
    insert(a);
    int sum = a;
    for(int i = 1; i < n; i++){
        cin >> a;
        if(insert(a))
            sum += min(a-key[getpre(rt)], key[getnxt(rt)]-a);//a已经转为根，直接找rt的pre和next
        //cout<<"i="<<i <<" "<<sum <<" "<<key[getpre(rt)]<<" "<<key[getnxt(rt)]<<endl;
    }
    cout << sum <<endl;
    return 0;
}

//Hdu1754 splay单点修改，区间查询
//https://files.cnblogs.com/files/tony-/Splay%E5%9F%BA%E7%A1%80_%E6%A8%A1%E6%9D%BF.pdf
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 200010

int rt, tot;
int key[N],ch[N][2], pre[N], p[N],  cnt[N],    maxi[N],     siz[N];
//  结点的值 儿子    父亲 数组的值 本结点规模 子树最大值 包含自身的子树大小

void inline push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + cnt[u];
    maxi[u] = max(max(maxi[l(u)],maxi[r(u)]), key[u]);
}

int inline getkth(int u, int k){
    int s = siz[l(u)];
    if(s==k)
        return u;
    if(s>k)
        return getkth(l(u), k);
    return getkth(r(u), k-s-1);
}

void inline rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;   
    pre[fa] = u;
    push_up(fa);
}

void inline splay(int u, int goal){//将节点u旋转为goal的儿子
    while(pre[u] != goal){
        if(pre[pre[u]] == goal){//爷爷是目标，只旋转一次
            rotate(u, l(pre[u])==u);
        }else{
            int fa, dir;
            fa = pre[u];
            dir = l(pre[fa]) == fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

int inline query(int l, int r){
    splay(getkth(rt,l-1), 0);
    splay(getkth(rt,r+1), rt);
    return maxi[keytree];
}

void inline update(int k,int val){
    int u = getkth(rt, k);
    splay(u, 0);
    key[u] = val;
    push_up(u);
}

void inline newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = cnt[u] = 1;
    key[u] = maxi[u] = val;
}

void inline build(int &u, int l, int r, int fa){
    if(l>r)
        return;
    int mid = (l+r)>>1;
    newnode(u, fa, p[mid]);
    build(l(u), l, mid-1, u);
    build(r(u), mid+1, r, u);
    push_up(u);
}

void inline init(int n){
    rt = tot = 0;
    l(rt) = r(rt) = pre[rt] = siz[rt] = cnt[rt] = 0;
    key[rt] = maxi[rt] = -1;
    newnode(rt,0,-1);//插入两个虚点
    newnode(r(rt),rt,-1);
    build(keytree, 1, n, r(rt));
    push_up(r(rt));
    push_up(rt);
}

int main() {
    int n, m;
    while(~scanf("%d%d", &n, &m)){
        for(int i = 1; i <= n; i++)
            scanf("%d",&p[i]);
        init(n);
        char sh[2];
        while(m--){
            scanf("%s",sh);
            if(sh[0]=='Q'){
                int l, r;
                scanf("%d%d",&l, &r);
                cout << query(l, r) << endl;
            }else{
                int k, val;
                scanf("%d%d",&k, &val);
                update(k, val);
            }
        }
    }
    return 0;
}

//Poj3468 区间修改，区间查询
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 100010

int rt, tot;
ll sum[N];//延迟更新 子树结点和
int add[N],  key[N],  ch[N][2], pre[N], p[N],   siz[N];
// 要更新的值 结点的值  儿子    父亲 数组的值 本结点规模 

void inline push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + 1;
    sum[u] = sum[l(u)] + sum[r(u)] + key[u] + add[u];
}

void push_down(int u){
    if(add[u]){//将延迟标记更新到孩子结点
        key[u] += add[u];
        add[l(u)] += add[u];
        add[r(u)] += add[u];
        sum[l(u)] += 1ll*add[u]*siz[l(u)];
        sum[r(u)] += 1ll*add[u]*siz[r(u)];
        add[u] = 0;
    }
}

int inline getkth(int u, int k){//获取第k位,u是根
    push_down(u);
    int s = siz[l(u)];
    if(s==k)
        return u;
    if(s>k)
        return getkth(l(u), k);
    return getkth(r(u), k-s-1);
}

void inline rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;
    pre[fa] = u;
    push_up(fa);
}

void inline splay(int u, int goal){//将节点u旋转为goal的儿子
    push_down(u);
    while(pre[u] != goal){
        int fa, dir;
        fa = pre[u];
        if(pre[fa] == goal){//爷爷是目标，只旋转一次
            push_down(fa);
            push_down(u);
            rotate(u, l(fa)==u);
        }else{
            push_down(pre[fa]);
            push_down(fa);
            push_down(u);
            dir = l(pre[fa])==fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

ll inline query(int l, int r){
    splay(getkth(rt,l-1), 0);
    splay(getkth(rt,r+1), rt);
    return sum[keytree];
}

void inline update(int l, int r,int val){
    splay(getkth(rt,l-1), 0);
    splay(getkth(rt,r+1), rt);
    add[keytree] += val;
    sum[keytree] += siz[keytree]*val;
}

void inline newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = 1;
    key[u] = sum[u] = val;
    add[u] = 0;
}

void inline build(int &u, int l, int r, int fa){
    if(l>r)//建树 中间结点先建立 然后分别对区间两端在左右子树建立
        return;
    int mid = (l+r)>>1;
    newnode(u, fa, p[mid]);
    build(l(u), l, mid-1, u);
    build(r(u), mid+1, r, u);
    push_up(u);
}

void inline init(int n){
    rt = tot = 0;
    l(rt) = r(rt) = pre[rt] = siz[rt] = 0;
    add[rt] = sum[rt] = 0;
    newnode(rt, 0, -1);//插入两个虚点
    newnode(r(rt), rt, -1);
    siz[rt] = 2;
}

int main() {
    int n, m;
    while(~scanf("%d%d", &n, &m)){
        for(int i = 1; i <= n; i++)
            scanf("%d",&p[i]);
        init(n);
        build(keytree, 1, n, r(rt));
        push_up(r(rt));
        push_up(rt);
        char sh[2];
        while(m--){
            scanf("%s",sh);
            int l, r, val;
            if(sh[0]=='Q'){
                scanf("%d%d",&l, &r);
                cout << query(l, r) << endl;
            }else{
                scanf("%d%d%d", &l, &r, &val);
                update(l, r, val);
            }
        }
    }
    return 0;
}

//Hdu1890 splay区间翻转
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 100010

struct g{
    int num, id;
    bool operator < (const g c) const{
        if(num==c.num) return id<c.id;
        return num < c.num;
    }
}p[N];

int rt, tot, id[N], mini[N];//子树的最小值
int key[N],  ch[N][2], pre[N],  siz[N], flip[N];
// 结点的值  儿子    父亲  本结点规模  是否翻转

void inline push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + 1;
    mini[u] = min(key[u], min(mini[l(u)], mini[r(u)]));
}

void push_down(int u){//延迟更新，翻转
    if(flip[u]){
        if(l(u))
            flip[l(u)] ^= 1;
        if(r(u))
            flip[r(u)] ^= 1;
        swap(l(u), r(u));
        flip[u] = 0;
    }
}

int inline getkth(int u, int k){//获取第k位,u是根
    push_down(u);
    int s = siz[l(u)] + 1;
    if(s==k)
        return u;
    if(s>k)
        return getkth(l(u), k);
    return getkth(r(u), k-s);
}

void inline rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;
    pre[fa] = u;
    push_up(fa);
}

void inline splay(int u, int goal){//将节点u旋转为goal的儿子
    push_down(u);
    while(pre[u] != goal){
        int fa, dir;
        fa = pre[u];
        if(pre[fa] == goal){//爷爷是目标，只旋转一次
            push_down(fa);
            push_down(u);
            rotate(u, l(fa)==u);
        }else{
            push_down(pre[fa]);
            push_down(fa);
            push_down(u);
            dir = l(pre[fa])==fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

int getpre(int u){//求u的前驱
    push_down(u);
    u = l(u);
    push_down(u);
    while(r(u)){
        u = r(u);
        push_down(u);
    }
    return u;
}

void del(int u){//旋转到根然后删去
    splay(getkth(rt, u), 0);
    if(l(rt)){
        int i = getpre(rt);
        splay(i, rt);
        r(i) = r(rt);
        pre[r(rt)] = i;
        rt = l(rt);
        pre[rt] = 0;
        push_up(rt);
    }else{
        rt = r(rt);
        pre[rt] = 0;
    }
}

void inline newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = 1;
    mini[u] = key[u] = val;
    flip[u] = 0;
}

void inline build(int &u, int l, int r, int fa){
    if(l>r)//建树 中间结点先建立 然后分别对区间两端在左右子树建立
        return;
    int mid = (l+r)>>1;
    newnode(u, fa, id[mid]);
    build(l(u), l, mid-1, u);
    build(r(u), mid+1, r, u);
    push_up(u);
}

void inline init(int n){
    rt = tot = 0;
    l(rt) = r(rt) = pre[rt] = siz[rt] = flip[rt] = 0;
    key[rt] = mini[rt] = N;
    newnode(rt, 0, INF);//插入两个虚点
    newnode(r(rt), rt, INF);
    build(keytree, 1, n, r(rt));
    push_up(r(rt));
    push_up(rt);
}

int getmin(int u, int x){//求子树的最小值
    push_down(u);
    if(key[u] == x)
        return 1 + siz[l(u)];
    if(mini[l(u)] == x)
        return getmin(l(u),x);
    if(mini[r(u)] == x)
        return siz[l(u)]+getmin(r(u),x)+1;
}

int main() {
    int n;
    while(~scanf("%d", &n) && n){
        for(int i = 1; i <= n; i++){
            scanf("%d",&p[i].num);
            p[i].id = i;
        }
        sort(p+1, p+n+1);
        for(int i = 1; i <= n; i++)
            id[p[i].id] = i;//重新做个标记
        init(n);
        for(int i = 1; i < n; i++){
            int ans = getmin(rt, i);//找到值i的位置
            cout << ans+i-2;
            if(i<n)
                cout << " ";
            splay(getkth(rt,1), 0);
            splay(getkth(rt,ans), rt);
            flip[keytree] ^= 1;
            del(ans);
        }cout << n << endl;
    }
    return 0;
}

//Hysbz1269 splay区间旋转
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 2*1024*1024+2

char sh[N];
int pos;
int rt, tot;
int key[N],  ch[N][2], pre[N],  siz[N], flip[N];
// 结点的值  儿子    父亲  本结点规模  是否翻转

void visit(int u){//for test
    if(!u) return;
    visit(l(u));
    printf("u:%d lch:%d rch:%d key:%c pos:%d
",u,l(u),r(u),key[u],pos);
    visit(r(u));
}

void push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + 1;
}

void push_down(int u){//延迟更新，翻转
    if(flip[u]){
        flip[l(u)] ^= 1;
        flip[r(u)] ^= 1;
        swap(l(u), r(u));
        flip[u] = 0;
    }
}

void rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;
    pre[fa] = u;
    push_up(fa);
}

void splay(int u, int goal){//将节点u旋转为goal的儿子
    push_down(u);
    while(pre[u] != goal){
        int fa, dir;
        fa = pre[u];
        if(pre[fa] == goal){//爷爷是目标，只旋转一次
            push_down(fa);
            push_down(u);
            rotate(u, l(fa)==u);
        }else{
            push_down(pre[fa]);
            push_down(fa);
            push_down(u);
            dir = l(pre[fa])==fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

int getkth(int u, int t){//获取第t位,u是根
    push_down(u);
    int s = siz[l(u)];
    if(s==t)
        return u;
    if(s>t)
        return getkth(l(u),t);
    return getkth(r(u), t-s-1);
}

void insert(int u, int x){//插入x到k尾部
    splay(getkth(rt,u), 0);
    splay(getkth(rt,u+1), rt);
    pre[x] = r(rt);
    keytree = x;
    push_up(r(rt));
    push_up(rt);
}

void newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = 1;
    flip[u] = 0;
    key[u] = val;
}

void build(int &u, int l, int r, int fa){
    if(l > r) return;
    int mid = (l+r)>>1;
    newnode(u,fa,(int)sh[mid]);
    build(l(u),l,mid-1,u);
    build(r(u),mid+1,r,u);
    push_up(u);
}

void init(){
    rt = tot = 0;
    key[rt] = l(rt) = r(rt) = pre[rt] = siz[rt] = flip[rt] = 0;
    newnode(rt, 0, -1);//插入两个虚点
    newnode(r(rt), rt, -1);
    push_up(r(rt));
    push_up(rt);
}

void del(int u, int p){
    splay(getkth(rt,u), 0);
    splay(getkth(rt,u+p+1), rt);
    keytree = 0;
    push_up(r(rt));
    push_up(rt);
}

void flipp(int u, int p){
    splay(getkth(rt, u), 0);
    splay(getkth(rt, u+p+1), rt);
    flip[keytree] ^= 1;
}

int got(int p){
    splay(getkth(rt, p+1), 0);
    return key[rt];
}

int main() {
    int t;
    scanf("%d",&t);
    pos = 0;//初始光标位置
    init();
    while(t--){
        char q[20];
        scanf("%s",q);
        int n;
        if(q[0]=='M'){//move
            scanf("%d",&pos);
        }else if(q[0]=='I'){//insert
            scanf("%d",&n);
            getchar();
            gets(sh);
            int newrt = 0;
            build(newrt, 0, n-1, 0);
            insert(pos, newrt);
        }else if(q[0]=='D'){//delete
            scanf("%d",&n);
            del(pos,n);
        }else if(q[0]=='R'){//rotate
            scanf("%d",&n);
            flipp(pos, n);
        }else if(q[0]=='G'){//get
            printf("!!!!!!!%c!!!!!!!!
", got(pos));
        }else if(q[0]=='P'){//prev
            pos--;
        }else if(q[0]=='N'){//next
            pos++;
        }   
        //visit(rt);
    }
    return 0;
}

//Hysbz3223 splay区间翻转 裸
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 100010

int rt, tot, id[N];//子树的最小值
int key[N],  ch[N][2], pre[N],  siz[N], flip[N];
// 结点的值  儿子    父亲  本结点规模  是否翻转

void inline push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + 1;
}

void push_down(int u){//延迟更新，翻转
    if(flip[u]){
        flip[l(u)] ^= 1;
        flip[r(u)] ^= 1;
        swap(l(u), r(u));
        flip[u] = 0;
    }
}

int inline getkth(int u, int k){//获取第k位,u是根
    push_down(u);
    int s = siz[l(u)];
    if(s==k)
        return u;
    if(s>k)
        return getkth(l(u), k);
    return getkth(r(u), k-s-1);
}

void inline rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;
    pre[fa] = u;
    push_up(fa);
}

void inline splay(int u, int goal){//将节点u旋转为goal的儿子
    push_down(u);
    while(pre[u] != goal){
        int fa, dir;
        fa = pre[u];
        if(pre[fa] == goal){//爷爷是目标，只旋转一次
            push_down(fa);
            push_down(u);
            rotate(u, l(fa)==u);
        }else{
            push_down(pre[fa]);
            push_down(fa);
            push_down(u);
            dir = l(pre[fa])==fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

void inline newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = 1;
    key[u] = val;
    flip[u] = 0;
}

void inline build(int &u, int l, int r, int fa){
    if(l>r)//建树 中间结点先建立 然后分别对区间两端在左右子树建立
        return;
    int mid = (l+r)>>1;
    newnode(u, fa, id[mid]);
    build(l(u), l, mid-1, u);
    build(r(u), mid+1, r, u);
    push_up(u);
}

void init(int n){
    rt = tot = 0;
    l(rt) = r(rt) = pre[rt] = siz[rt] = flip[rt] = 0;
    key[rt] = N;
    newnode(rt, 0, INF);//插入两个虚点
    newnode(r(rt), rt, INF);
    build(keytree, 1, n, r(rt));
    push_up(r(rt));
    push_up(rt);
}

void out(int x){
    if(!x) return;
    push_down(x);
    out(l(x));
    if(key[x]!=INF)
        printf("%d ",key[x]);
    out(r(x));
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++)
        id[i] = i;
    init(n);

    for(int i = 0; i < m; i++){
        int l, r;
        scanf("%d%d", &l, &r);
        splay(getkth(rt,l-1),0);
        splay(getkth(rt,r+1),rt);
        flip[keytree] ^= 1;
        //cout<< rt<<" "<<id[rt]<<endl;
    }
    out(rt);
    return 0;
}

//Hysbz3224 splay
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define l(x) ch[x][0]
#define r(x) ch[x][1]
using namespace std;

#define INF 0x3f3f3f3f
#define ll long long
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define keytree ch[ch[rt][1]][0]
#define N 100002

int rt, tot;
int key[N],  ch[N][2], pre[N], siz[N], cnt[N];
// 结点的值  儿子     父亲  本结点规模

void visit(int u){//for test
    if(!u) return;
    visit(l(u));
    printf("u:%d lch:%d rch:%d key:%c
",u,l(u),r(u),key[u]);
    visit(r(u));
}

int getpre(int u){
    u = l(u);
    while(r(u)){
        u=r(u);
    }
    return u;
}

int getnxt(int u){
    u = r(u);
    while(l(u)){
        u=l(u);
    }
    return u;
}

void push_up(int u){
    siz[u] = siz[l(u)] + siz[r(u)] + cnt[u];
}

void rotate(int u, int dir){//dir=1是右旋
    int fa = pre[u];
    ch[fa][!dir] = ch[u][dir];
    pre[ch[u][dir]] = fa;
    if(pre[fa]){
        int son = ch[pre[fa]][1]==fa;
        ch[pre[fa]][son] = u;
    }
    pre[u] = pre[fa];
    ch[u][dir] = fa;
    pre[fa] = u;
    push_up(fa);
}

void inline splay(int u, int goal){//将节点u旋转为goal的儿子
    while(pre[u] != goal){
        if(pre[pre[u]] == goal){//爷爷是目标，只旋转一次
            rotate(u, l(pre[u])==u);
        }else{
            int fa, dir;
            fa = pre[u];
            dir = l(pre[fa]) == fa;//左儿子1，右儿子0
            if(ch[fa][dir] == u){//一左一右，两次方向相反的旋转
                rotate(u, !dir);
                rotate(u,dir);
            }else{//同左同右，先转父亲
                rotate(fa, dir);
                rotate(u, dir);
            }
        }
    }
    push_up(u);
    if(goal == 0)
        rt = u;
}

void newnode(int &u, int fa, int val){
    u = ++tot;
    l(u) = r(u) = 0;
    pre[u] = fa;
    siz[u] = cnt[u] = 1;
    key[u] = val;
}

void insert(int val){//插入val，将此节点旋转为根
    if(!rt)
        newnode(rt,0,val);
    else{
        int x = rt, fa = 0;
        while(x){
            if(key[x] == val){
                cnt[x]++;
                push_up(x);
                push_up(fa);
                splay(x,0);
                return;
            }
            fa = x;
            x = ch[x][key[x]<val];//val>当前节点 进入右儿子，反之xxxx
        }
        newnode(x, fa, val);//没有此结点
        ch[fa][key[fa]<val] = x;
        push_up(fa);
        splay(x, 0);
    }
}

int find(int x){//查询x的排名
    int nowrt = rt, ans = 0;
    while(1){
        if(x < key[nowrt])
            nowrt = l(nowrt);
        else{
            ans += l(nowrt)?siz[l(nowrt)]:0;
            if(x == key[nowrt]){
                splay(nowrt, 0);
                return ans + 1;
            }
            ans += cnt[nowrt];
            nowrt = r(nowrt);
        }
    }
}

int findx(int x){//排名为x的数
    int nowrt = rt;
    while(1){
        if(l(nowrt) && x<=siz[l(nowrt)]){
            nowrt = l(nowrt);
        }else{
            int ans = l(nowrt)?siz[l(nowrt)]:0;
            ans += cnt[nowrt];
            if(x <= ans)
                return key[nowrt];
            x -= ans;
            nowrt = r(nowrt);
        }
    }
}

void clear(int x){
    l(x) = r(x) = pre[x] = siz[x] = cnt[x] = 0;
}

void del(int x){//cnt==1 考虑有无左右儿子的情况
    find(x);
    if(cnt[rt] > 1){//cnt>1
        cnt[rt]--;
        return ;
    }
    if(!l(rt) && ! r(rt)){
        clear(rt);
        rt = 0;
        return;
    }
    if(!l(rt)){
        int oldrt = rt;
        rt = r(rt);
        pre[rt] = 0;
        clear(oldrt);
        return;
    }else if(!r(rt)){
        int oldrt = rt;
        rt = l(rt);
        pre[rt] = 0;
        clear(oldrt);
        return;
    }
    int oldrt = rt;
    splay(getpre(rt),0);
    pre[r(oldrt)] = rt;
    r(rt) = r(oldrt);
    clear(oldrt);
    push_up(rt);
}

int main() {
    int t;
    scanf("%d",&t);
    while(t--){
        int k, n;
        scanf("%d",&k);
        scanf("%d",&n);
        if(k==1){//insert
            insert(n);
        }else if(k==2){//delete
            del(n);
        }else if(k==3){//query
            printf("%d
", find(n));
        }else if(k==4){//query rank==n
            printf("%d
", findx(n));
        }else if(k==5){//prev
            insert(n);
            printf("%d
", key[getpre(rt)]);
            del(n);
        }else if(k==6){//next
            insert(n);
            printf("%d
", key[getnxt(rt)]);
            del(n);
        }
        //visit(rt);
    }
    return 0;
}

//最小边覆盖
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <string.h>
#include <stdlib.h>
using namespace std;

int o;
char g[50][50];
int edge[50][50];
int a[50][50];
int gg[50];
int vis[50];
int n ,m;
int cnt, ans;
int xn[] = {0,1,0,-1};
int yn[] = {1,0,-1,0};

void dfs(int x, int y){//cout << "now="<<x << " "<<y<<endl;
    if(g[x][y] == '*'){
        for(int i = 0; i < 4; i++){
            int x1 = x+xn[i], y1 = y+yn[i];
            if(x1>=0 && x1<n && y1>=0 && y1<m && g[x1][y1]=='*'){
                edge[a[x][y]][a[x1][y1]] = 1;
            }
        }
    }
}

int path(int u)
{
    int v;
    for(v=0; v<o; v++)
    {
        if(edge[u][v]&&!vis[v])
        {
            vis[v]=1;
            if(gg[v]==-1||path(gg[v]))
            {
                gg[v]=u;
                return 1;
            }
        }
    }
    return 0;
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        ans = 1;
        scanf("%d%d",&n,&m);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                scanf(" %c",&g[i][j]);
                if(g[i][j]=='*')
                    a[i][j] = ans++;
            }
        }
        o = ans;
        memset(edge,0,sizeof(edge));
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                dfs(i,j);
            }
        }
        int cnt = 0;
        memset(gg,-1,sizeof(gg));
        for(int i=0; i<o; i++)
        {
            memset(vis,0,sizeof(vis));
            cnt+=path(i);
        }
        cout << ans-1-cnt/2 << endl;
    }
    return 0;
}

//莫队算法
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
using namespace std;

int got[200010],sum[30010],ch[30010];
int ans;
struct stu{
    int l,r,p;
}node[200010];

int cmp(stu a, stu b){
    return a.l==b.l ? a.r<b.r : a.l<b.l;
}

void add(int x){
    if(!got[x])
        ans++;
    got[x]++;
}

void del(int x){
    got[x]--;
    if(!got[x])
        ans--;
}

int main()
{
    int n;
    while(~scanf("%d",&n)){
        for(int i = 1; i <= n; i++){
            scanf("%d",&ch[i]);
        }
        int m;
        scanf("%d",&m);
        for(int i = 1; i <= m; i++){
            scanf("%d%d",&node[i].l,&node[i].r);
            node[i].p = i;
        }
        sort(node,node+m,cmp);

        ans = 0;
        int l = 1, r = 0;
        memset(got,0,sizeof(got));
        for(int i = 1; i <= m; i++){
            while(r < node[i].r)
                add(ch[++r]);

            while(l > node[i].l)
                add(ch[--l]);

            while(r > node[i].r)
                del(ch[r--]);

            while(l < node[i].l)
                del(ch[l++]);

            sum[node[i].p] = ans;
        }
        for(int i = 1; i <= m; i++){
            printf("%d
", sum[i]);
        }

    }
    return 0;
}