以前写的破代码,不忍心扔


// 判断整数的正因子数目 
//#include<stdio.h>
//#include<math.h>
//
//int main()
//{
//  int n;
//    int i,count=2;
//    scanf("%d",&n);
//    int len=(int)sqrt((double)n);
//    for(i=2;i<=len;i++)
//    {
//        if(0==n%i)
//            if(i==n/i)
//                count++;
//            else
//                count+=2;
//    }
//    printf("正因子数目:%d\n",count);
//}

// 输出位数
//#include<stdio.h>
//int main()
//{
//    int n,i,count=0;
//    scanf("%d",&n);
//    for(i=1000000000;i>=1;i=i/10)
//    {
//        if(n/i!=0)
//            count++;
//    }
//    printf("%d\n",count);
//    return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//#include<memory.h>
//#include<string.h>
//#include<assert.h>
//#define MAX_LENGTH 1000
//
//int main()
//{
//    FILE *fp = fopen("a.txt","r");
//    long int pos;
//    char * str = (char*)malloc(MAX_LENGTH);
//    assert(str);
//    errno=0;
//    if(!fp)
//    {
//        fprintf(stderr,"a.txt failed.Erroe code:%s\n",strerror(errno));
//        return -1;
//    }
//    fscanf(fp,"%s",str);
//    puts(str);
//    fseek(fp,8L,SEEK_SET);
//    pos = ftell(fp);
//    if(-1L == pos && errno <= 0)
//    {
//        fprintf(stderr,"返回a.txt的指针当前读取位置失败. Error code: %s\n",strerror(errno));
//        return -1;
//    }
//    printf("指针当前位置为:%ld\n",pos);
//    fscanf(fp,"%s",str);    puts(str);
//    fseek(fp,20L,SEEK_SET);
//    fscanf(fp,"%s",str);    puts(str);
//    fseek(fp,pos,SEEK_SET);
//    fscanf(fp,"%s",str);    puts(str);
//    fclose(fp); // 关闭文件
//    free(str);
//    return 0;
//}

//#include "stdio.h"   
//#include <stdlib.h>  
//int main()
//{   
//    FILE *fp;
//    fp=fopen("myfile.txt","w");
//    if(fp==NULL)
//        printf("File can not be opened\n");
//    else
//        printf("File opened for writing\n");
//    if(fclose(fp)!=0)
//        printf("File not be closed\n");
//    else
//        printf("File is now closed\n");
//
//    FILE * fp;
//    char ch;
//    fp = fopen("myfile.txt","r");
//    if(fp==NULL)
//        printf("file cannot be opened\n");
//    while((fgetc(fp))!=EOF)
//        fputc(ch,stdout);
//    fclose(fp);
//    return 0;  
//}



// 水仙花数  有问题啊
//#include<stdio.h>
//int main()
//{
//    int i,count=0;
//    for(i=100;i<999;i++)
//    {
//        
//        if(i==((i=i/100)*(i/100)*(i/100)+(i/10%10)*(i/10%10)
//            *(i/10%10)+(i%10)*(i%10)*(i%10)));
//        {
//            printf("%d",i);
//            count++;
//        }
//    }
//    printf("%d",count);
//    return 0;
//}



//  韩信点兵
//#include<stdio.h>
//int main()
//{
//    int x,count=0;
//    int a,b,c;
//    scanf("%d %d %d",&a,&b,&c);
//    for(x=10;x<=100;x++)
//    {
//        if(x%3==a && x%5==b && x%7==c)
//        {
//            printf("%d\n",x);
//            count ++;
//        }
//    }
//    if(count==0)
//        printf("No answers");
//    return 0;
//}


// 倒三角
//#include<stdio.h>
//int main()
//{
//    int n,i,j,k;
//    scanf("%d",&n);
//    for(i=n;i>=1;i--)
//    {
//        for(k=0;k<n-i;k++)
//            printf(" ");
//        for(j=1;j<=2*i-1;j++)
//            printf("*");
//        printf("\n");
//    }
//    return 0;
//}


// stat 
//#include<stdio.h>
//int main()
//{
//    int  arr[100];
//    int n,m,i,count=0;
//    scanf("%d",&n);
//    for(i=0;i<n;i++)
//        scanf("%d",&arr[i]);
//    scanf("%d",&m);
//    for(i=0;i<n;i++)
//    {
//        if(m<arr[i])
//            count++;
//    }
//    printf("%d",count);
//    return 0;
//}

//#include<cstdio>  
//#pragma warning(disable:4996)  
////#define LOCAL  
//void main()  
//{  
//#ifdef LOCAl  
//    freopen("in.txt","r",stdin);  
//    freopen("out.txt","w",stdout);  
//#endif  
//    int n,m,i,j=0;  
//    scanf("%d",&n);  
//    int a[100];  
//    for(i=0;i<n;i++)  
//        scanf("%d",&a[i]);  
//    scanf("%d",&m);  
//    for(i=0;i<n;i++)  
//    {  
//        if(a[i]<m)  
//            j++;  
//    }  
//    printf("%d\n",j);  
//}

// 调和级数
//#include<stdio.h>
//int main()
//{
//    
//    // printf("%.3lf",1+double(1)/2+double(1)/3);
//    double sum=0;
//    int n;   
//    scanf("%d",&n);
//    for(int i=1;i<=n;i++)
//    {
//       /* double start =1;
//        start=start/i;*/
//        sum += double(1)/i;
//    }
//    printf("%.3lf",sum);
//    return 0;
//}


// 近似计算 求π的值
//#include<stdio.h>
//int main()
//{
//    
//    double num = 0.00000; 
//    int i;
//    for( i=1;double(1)/i - double(1)/(i+2)>=1/1000000;i=i+4)
//    {         
//        num += double(1)/i - double(1)/(i+2);
//        printf("π的值为: %lf.29\n",4*num);
//    }
//    printf("π的值为: %.29lf",4*num);
//    return 0;
//}
//
//  近似计算 正确版
//#include<stdio.h>
//int main(void)
//{
//    
//    double num = 0; 
//    int flag = 1; 
//    int i;
//    for(i=1; 1.0/i >= 0.000001; i+=2)
//    {         
//        num += (1.0/i * flag);
//        flag *= -1;
//    }
//    printf("π的值为: %.lf",4*num);
//    return 0;
//}
//
//#include<stdio.h>
//int main()
//{
//    int flag=1;
//    double num = 0;
//    int i;
//    for(i=1; 1.0/i >= 0.000001; i+=2)
//    {
//        num += (1.0/i*flag);
//        
//        flag *= -1;
//    }
//    printf("%lf",4*num);
//    return 0;
//}

//#include<stdio.h>
//int main()
//{
//    int m,n,i;
//    double sum=0;
//    scanf("%d %d",&n,&m);
//    if(n>m || m>1000000)
//        return -1;
//    for(i=n;i<=m;i++)
//    {
//        sum+=1.0/((long long )i*i);
//    }
//    printf("%.5lf",sum);
//    return 0;
//}


/// 不考虑四舍五入的情况
//#include<stdio.h>
//int main()
//{
//    int a,b,c;
//    int count = 1;
//    scanf("%d %d %d",&a,&b,&c);
//    if(a>1000000 || b>1000000 || c>100)
//        return -1;
//    printf("%d.",a/b);
//    while(count<=c)
//    {
//        a=a%b*10;
//        printf("%d",a/b);
//        count++;
//    }
//    return 0;
//}

// 带四舍五入的版本
//#include<stdio.h>
//int main()
//{
//    int a,b,c,count=1,x;
//    scanf("%d %d %d",&a,&b,&c);
//    printf("%d.",a/b);
//    a=a%b*10;
//    while(count<=c)
//    {
//        x=a/b;
//        if(count==c)
//            printf("%d",(a%b*10)/b>=5?x+1:x);
//        else
//            printf("%d",x);
//        a=a%b*10;
//        count++;
//    }
//    return 0;
//}


// permutation 
//#include<stdio.h>
//int main()
//{
//    int a,b,c,d,e,f,g,h,i;
//    for(a=1;a<=3;a++)
//        for(b=1;b<=9;b++)
//            if(a!=b)
//                for(c=1;c<=9;c++)
//                    if(a!=c && b!=c)
//                        for(d=2*a;d<=6;d++)
//                            if(a!=d && b!=d && c!=d )
//                                for(e=1;e<=9;e++)
//                                    if(a!=e && b!=e && c!=e && d!=e)
//                                        for(f=1;f<=9;f++)
//                                            if(a!=f && b!=f && c!=f && d!=f && e!=f)
//                                                for(g=3*a;g<=9;g++)
//                                                    if(a!=g && b!=g && c!=g && d!=g && e!=g && f!=g )
//                                                        for(h=1;h<=9;h++)
//                                                            if(a!=h && b!=h && c!=h && d!=h && e!=h && f!=h && g!= h)
//                                                                for(i=1;i<=9;i++)
//                                                                    if(i!=a && i!=b && i!=c && i!=d && i!=e && i!=f && i!=g && i!=h)
//                                                                        if((d*100+e*10+f)==2*(a*100+b*10+c) && (g*100+h*10+i)==3*(a*100+b*10+c))
//                                                                        { printf("%d\n",a*100+b*10+c);printf("%d\n",d*100+e*10+f);printf("%d\n",g*100+h*10+i);printf("\n\n");}
//                                                                           
//    
//    return 0;
//}



// 逆序输出
//#include<stdio.h>
//#define MAX 100 + 10
//int main()
//{
//    int arr[MAX];
//    int i,x, n=0;
//    while(scanf("%d",&x)==1)
//        arr[n++] = x;
//    for(i=n-1;i>=0;i--)
//        printf("%d",arr[i]);
//    printf("\n");
//    printf("%d",arr[0]);
//    return 0;
//}

// 开灯问题
//#include<stdio.h>
//#include<string.h>
//#define MAX 1000 + 10
//int main()
//{
//    int arr[MAX];
//    int i,j,n,k,first = 1;
//    memset(arr,0,sizeof(arr));
//    scanf("%d %d",&n,&k);
//    for(i=1;i<=k;i++)
//        for(j=1;j<=n;j++)
//            if(j%i==0) arr[j] =! arr[j];
//
//    for(i=1;i<=n;i++)
//        if(arr[i])
//        {
//            if(first) {first = 0;printf("%d",arr[i]);}
//            else
//            {
//                printf(" "); printf("%d",i);
//            }     
//        }
//    printf("\n");
//    
//
//    return 0;
//}


//#include<stdio.h>
//int main()
//{
//    int arr[10];
//    arr[0]=0;
//    arr[0] = !arr[0];
//    printf("%d",arr[0]);
//    return 0;
//}

//#include<stdio.h>
//int main()
//{
//    printf("%d",2%4);
//    return 0;
//
//}


//#include<iostream>
//using namespace std;
//   void SwapInt(int *p,int *q)
//  {
//      
//      int temp = *p;
//      *p = *q;
//      *q = temp; 
//  }
//int main()
//{
//  int a=3;
//  int b=5;
//  SwapInt(&a,&b);
//  cout << a << " " << b << endl;  
//  return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int a=100;
//    while(a<=999)
//    {
//        if((a/100)*(a/100)*(a/100)+(a/10%10)*(a/10%10)*(a/10%10)+(a%10)*(a%10)*(a%10)==a)
//            cout << a << endl;
//        a++;
//    }
//    return 0;
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//    for(int a=1000;a<10000;a++)
//    {
//        if((a/1000==a%10) && (a/100%10==a/10%10))
//            cout << a << endl;
//    }
//    return 0;
//
//}
//
//#include<iostream>
//using namespace std;
//int main()
//{
//    int m;
//    cin >> m;   
//    for(int n=10000;n<100000;n++)
//    {
//        int a = n/10000;
//        int b = n/1000%10;
//        int c = n/100%10;
//        int d = n/10%10;
//        int e = n%10;
//        if ((a==e) &&(b==d))
//        {
//            if(a+b+c+d+e==m)
//                cout << n << endl;
//        }
//    }
//    for(int b=100000;b<1000000;b++)
//    {
//        int q=b/100000;
//        int w=b/10000%10;
//        int e=b/1000%10;
//        int r=b/100%10;
//        int t=b/10%10;
//        int y=b%10;
//        if((q==y) && (w==t) && (e==r) )
//            if(q+w+e+r+t+y == m)
//                cout << b << endl;
//    }
//    return 0;
//


//#include <iostream>  
//#include <stdio.h>  
//#include <list>  
//using namespace std;   
//char p[2];   
////char Exchange(int number)  
////功能:将输入的数字转为对应的十六进制字符   
//char Exchange(int number)  
//{  
//    if(number < 10)  
//    {  
//        sprintf(p,"%d",number);//将int型数据写入p字符串中   
//        return p[0];  
//    }  
//    else  
//    {  
//        switch(number)  
//        {  
//            case 10:return 'A';  
//            case 11:return 'B';  
//            case 12:return 'C';  
//            case 13:return 'D';  
//            case 14:return 'E';  
//            case 15:return 'F';  
//        }  
//    }  
//}  
//int main()   
//{  
//    list<char>exp;  
//    unsigned int num;//记录待转化的数   
//                     //unsigned int 0 ~ 4294967295  
//    cin>>num;  
//    if(num == 0)//输入为0的情况   
//    {  
//        cout<<num<<endl;  
//    }  
//    else//输入大于0的情况   
//    {  
//        int re;//记录余值   
//        while(num > 0)  
//        {  
//            re = num%16;  
//            exp.push_front(Exchange(re));   
//            num /= 16;    
//        }     
//        int size = exp.size();  
//        while(size--)//输出  
//        {  
//            cout<<exp.front();  
//            exp.pop_front();  
//        }  
//    }  
//    return 0;  
//}  

//
//#include<iostream>
//#include<string.h>
//using namespace std;
//char str[10];
//char Ex(int num)
//{
//   if(num<10)
//       return num + '0';
//   else
//       return num - 10 + 'A';
//}
//int main()
//{
//    unsigned int num;
//    cin >> num;
//    int i=0;
//    while(num>0)
//    {
//        char re = num % 16;
//        str[i++] = Ex(re);
//        num /= 16;
//    }
//    int len = strlen(str)-1;
//    for(;len>=0;len--)
//        cout << str[len] ;
//    return 0;
//}

//#include<iostream>
//#include<math.h>
//#include<string.h>
//using namespace std;
//
//
//int main()
//{
//    long long  num=0;
//    char str[8];
//    cin >> str ;
//    int  re;
//    int len = strlen(str);
//    for (int i=0;i<len;i++)
//    {
//        if(str[i]>='A')
//            num += (str[i]-'A'+10) * pow(16,len-1-i);
//        else
//            num += (str[i]-'0')*pow(16,len-1-i);
//    }
//    cout << num << endl;
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    char hex_num[9];
//    cin >> hex_num;
//    int l;  // 十六进制数长度
//    long long dnum = 0;
//    for(l=0;hex_num[l]!='\0';l++);  // 这个6啊 你他么的 用strlen()不就行了吗
//    cout << l << endl;
//
//    for(int i=l-1;i>=0;i--){    // 位权展开法
//        int num;
//        long long weight = l;   // 权值
//        if('0'<=hex_num[i] && hex_num[i]<='9')
//            num = hex_num[i] - '0';
//        else if ('A'<=hex_num[i] && hex_num[i]<='F')
//            num = hex_num[i] - 'A' + 10;
//        for(int j=l-1;j>1;j--)
//            weight*=16;
//       
//        dnum+=num*weight;
//        cout << dnum << endl;
//    }
//    cout << dnum << endl;
//    return 0;
//}

//#include<iostream>  
//#include<cmath>  
//#include<string>  
//using namespace std;  
//int main()  
//{  
//    string hex;  
//    long long dec = 0;  
//    cin>>hex;  
//    int len = hex.length();  
//    for(int i=0 ;i<len;i++)  
//    {  
//        if(hex[i] >= 'A')  
//        {  
//            dec += (hex[i] - 'A' + 10)*pow(16,len-1-i);   
//        }  
//        else  
//        {  
//            dec += (hex[i] - '0')*pow(16,len-1-i);  
//        }  
//    }  
//    cout<<dec;  
//    return 0;  
//}

//#include<iostream>
//#include<math.h>
//#include<string.h>
//using namespace std;
//
//int Ex(char s)
//{
//    if(s>='0' && s<='9')
//        return s - '0';
//    else if(s>='A' && s<='F')
//        return s - 'A' + 10;
//}
//int main()
//{
//    long long  num=0;
//    char str[8];
//    cin >> str ;
//    int  re;
//    int len = strlen(str)-1;
//    for(int i=len;i>=0;i--)
//    {
//         re = Ex(str[i]);    
//        
//         num += pow(16,len-i) * re;
//         
//    }
//    cout << num << endl;
//    return 0;
//}


//#include<iostream>
//#include<string>
//using namespace std;
//
//int main()
//{
//    int n;
//    cin >> n;
//
//    return 0;
//}


//#include <iostream>
//#include <string>
//#include <cmath>
//using namespace std;
//int arr[10000001]; // 记录八进制的数
//
//int main()
//{
//  string str;
//  int n,m,i,num,j;
//  
//  cin>>n;
//  while(n--)
//  {
//      cin>>str;
//      m=str.length();
//      // 转换成十进制
//      num=0;
//      for(i=m-1;i>=0;--i)
//      {
//          if(str[i]>='0'&&str[i]<='9')
//              num+=pow(16,m-1-i)*(str[i]-'0');
//          else if(str[i]>='A'&&str[i]<='F')
//              num+=pow(16,m-1-i)*(str[i]-'A'+10);
//      }
//      
//      i=0;
//      while(num/8!=0)
//      {
//          arr[i]=num%8;
//          num/=8;
//          ++i;
//      }
//      arr[i]=num;
//
//      for(j=i;j>=0;--j)
//          cout<<arr[j];
//      cout<<endl;
//
//  }
//  return 0;
//}

// 十六进制转换八进制
//#include <iostream>
//#include <string>
//using namespace std;
//int arr[10000001];
//
//int main()
//{
//  int n,len_str,i,j;
//  string str,str2;
//  cin>>n;
//  while(n--)
//  {
//      cin>>str;
//      len_str=str.length();
//      str2="";
//
//      // 十六进制转换为二进制
//      for(i=0;i<len_str;++i)
//      {
//          switch(str[i])
//          {
//          case '0':str2+="0000";break;
//          case '1':str2+="0001";break;
//          case '2':str2+="0010";break;
//          case '3':str2+="0011";break;
//          case '4':str2+="0100";break;
//          case '5':str2+="0101";break;
//          case '6':str2+="0110";break;
//          case '7':str2+="0111";break;
//          case '8':str2+="1000";break;
//          case '9':str2+="1001";break;
//          case 'A':str2+="1010";break;
//          case 'B':str2+="1011";break;
//          case 'C':str2+="1100";break;
//          case 'D':str2+="1101";break;
//          case 'E':str2+="1110";break;
//          case 'F':str2+="1111";break;
//          default:break;
//          }
//      }
//      
//      // 修正位数
//      if(len_str%3==1)    str2="00"+str2;
//      
//      else if(len_str%3==2)   str2="0"+str2;
//
//      
//      len_str=str2.length();
//      // 二进制转换八进制
//      j=0;
//      for(i=0;i<len_str-2;i+=3)
//      {
//          arr[j]=(str2[i]-'0')*4+(str2[i+1]-'0')*2+(str2[i+2]-'0');
//          ++j;
//      }
//
//      for(i=0;i<j;++i)
//      {
//          if(i==0 && arr[i]==0)   continue;
//          cout<<arr[i];
//      }
//      cout<<endl;
//
//  }
//  return 0;
//}

//
//#include<iostream>
//using namespace std;
//int num[100];
//int main()
//{
//    int len;
//    cin >> len;
//    if(len>200 || len<0)    return 0;
//    for (int i=0;i<len;i++)
//    {
//        cin >> num[i];
//    }
//    for(int m=0;m<len;m++)
//    {
//        for(int n=0;n<len-m-1;n++)
//        {
//            if(num[n]>num[n+1])
//            {
//                int temp = num[n];
//                num[n] = num[n+1];
//                num[n+1] = temp;
//            }
//        }
//    }
//    for(int j=0;j<len;j++)
//        cout << num[j] << " " ;
//    return 0;
//}

//#include<iostream>
//#include<algorithm>
//using namespace std;
//int num[1001];
//int main()
//{
//    int n,m,l,r,k;
//    cin >> n;
//    for(int i=1;i<n;i++)
//        cin >> num[i];
//    cin >> m;
//    while(m--)
//    {
//        cin >> l >> r >> k;
//        int j=0;
//        int b[1001];
//        int len = r-l+1;
//        for(int i=l;i<=r;i++)
//            b[j++] = num[i];
//        sort(b,b+len);
//        cout << b[len-k] << endl;
//    }
//    return 0;
//}
//
//
//// 这是标准的
//
//#include<cstdio>
//#include<cstring>
//#include<iostream>
//#include<algorithm>
//using namespace std;
//int main()
//{
// int n,m,a[1001],k,l,r; 
// //scanf("%d",&n);
// cin >> n;
// for(int i=1;i<=n;i++)
//     //scanf("%d",&a[i]);
//     cin >> a[i];
// //scanf("%d",&m);
// cin >> m;
// while(m--){
//  //scanf("%d%d%d",&l,&r,&k);
//  cin >> l >> r >> k;
//  int b[1001];
//  int j=0,len=r-l+1;
//  for(int i=l;i<=r;i++){
//   b[j++]=a[i];
//  }
//  sort(b,b+len);
//  //printf("%d\n",b[len-k]);
//  cout << b[len-k] << endl;
// }
// return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    long long n,ans;
//    cin >> n;
//    if(n<=2)
//        ans = n;
//    else if(n%2==1)
//        ans = n*(n-1)*(n-2);
//    else 
//    {
//        if(n%3==0)
//            ans = (n-1)*(n-2)*(n-3);
//        else
//            ans = n*(n-1)*(n-3);
//    }
//    cout << ans << endl;
//    return 0;
//}


//#include<stdio.h>
//#define N 30
//int main()
//{
//  int i,m;
//  struct student {
//      char name [20];
//      int flag;
//      union score {
//          float fg;
//          char cg;
//      }grade;
//  } s[N],*p;
//  printf("请输入学生人数(1-%d):\n");
//  scanf("%d",&m);
//  for(i=0;i<m;i++)
//  {
//      printf("请输入姓名、是否必修(1/0):\n");
//      scanf("%s%d",&s[i].name,&s[i].flag);
//      printf("请输入成绩:\n");
//      switch(s[i].flag)
//      {
//          case 1:scanf("%d",&s[i].grade.fg);
//          break;
//          case 0:scanf("%c",&s[i].grade.cg);
//          break;
//          default:printf("输入形式错,退出运行\n");
//          
//      }
//  }
//  printf("\n必修名单  成绩\n");
//  for(p=s;p<s+m;p++)
//  if(p->flag)
//        printf("%9s%6.1f\n",p->grade.fg);
//  printf("\n选修名单  成绩\n");
//  for(p=s;p<s+m;p++)
//  if(!p->flag)
//        printf("%9s%5c\n",p->name,p->grade.cg);
//    return 0;
//}

//#include<iostream>
//#include<cstdio>
//#include<cstdlib>
//#include<algorithm>
//#include<queue>
//#include<stack>
//#include<cstring>
//#include<climits>
//#include<cmath>
//#include<cctype>
//
//typedef long long ll;
//using namespace std;
//const int mod = 1000000007;
//
//int dp[110][110];
//
//int main()
//{
//    int k,l;
//    while(scanf("%d%d",&k,&l) != EOF)
//    {
//        memset(dp,0,sizeof(dp));
//        for(int i=0;i<k;i++)
//        {
//            dp[1][i] = 1;
//        }
//        for(int i=2;i<=l;i++)
//        {
//            for(int j=0;j<k;j++)
//            {
//                for(int f=0;f<k;f++)
//                {
//                    if(f+1!=j && f-1!=j)
//                    {
//                        dp[i][j] += dp[i-1][f];
//                        dp[i][j] %= mod;
//
//                    }
//                }
//            }
//        }
//        
//        int sum = 0;
//        for(int i=1;i<k;i++)
//        {
//            sum += dp[l][i];
//            sum %= mod;
//        }
//        printf("%d\n",sum);
//    }
//    return 0;
//}


//#include<stdio.h>
//#include<string.h>
//#define _Max 100010
//#define max(a,b) a > b ? a : b 
//
//struct point
//{
//    int v,next;     // v指向这条边的另一个节点(父节点) next指向子节点 
//} edge[_Max*2];     // 一条边记录两次 分别以一个点做记录
//
//int head[_Max];
//int M;
//int dp[_Max][2];
//
//// 添加一个边
//void addEdge(int from,int to)
//{
//    // from节点
//    edge[M].v = to;
//    edge[M].next = head[from];  // 为-1则定位叶节点 否则 指向另一条边
//    head[from] = M++;       // 指定她的一条边 增加节点 
//    // to 节点 
//    edge[M].v = from;
//    edge[M].next = head[to];    // 为-1 则定位叶节点 否则 指向另外一条边
//    head[to] = M++;             // 指向她的一条边 增加节点
//    return;
//}
//
//// 深度遍历 先深入到叶子节点 然后一层一层往上会回升 一直到根节点 即第一个节点(初始pre为-1是因为根节点没有父节点 用-1表示)
//void dfs(int x,int pre)
//{
//    int i = head[x],v;
//    for(; i!=-1; i=edge[i].next )   // i != -1 说明有子节点 则遍历子节点 否则为叶子节点
//    {
//        v = edge[i].v;
//        if(pre==v)      // 如果指向的子节点和父节点重合 则说明这个节点叶子节点 不需要进一步dp
//        {
//            continue;
//        }
//        dfs(v,x);   // x可以理解为父节点
//        // 深度遍历到最里面的叶子节点的父节点  如果父节点选择 则子节点不选择 否则子节点可能选择或不选择 但要比较两者那个
//        dp[x][1] += dp[v][0];   // 父节点(选) += 子节点(不选)
//        dp[x][0] += max(dp[v][0],dp[v][1]);     // 父节点(不选) += max(子节点(不选),子节点(选))
//    }
//    return;
//
//}
//
//int main()
//{
//    int i,n,s,t,tmp;
//    scanf("%d",&n);
//    M = 0;
//    memset(head,-1,sizeof(head));   // 初始化每个节点都是独立的没有子节点 
//    memset(dp,0,sizeof(dp));
//    // 输入权值 并且记录在dp[i][1]上 i表示第i个节点 1 代表取了这个节点
//    for(i=1;i<=n;i++)
//    {
//        scanf("%d",&dp[i][1]);
//    }
//    // 输入边 并且添加edge 一个边添加两个edge 
//    for(int i=1;i<n;i++)
//    {
//        scanf("%d %d",&s,&t);
//        addEdge(s,t);
//    }
//    dfs(1,-1);  // 深度优先遍历 从第一个节点开始遍历 
//    tmp = max(dp[1][0],dp[1][1]);   // 求出最大的权值和
//    printf("%d\n",tmp);
//    return 0;
//}

//#include<iostream>
//#include<cstdio>
//#include<queue>
//#include<algorithm>
//#include<cstring>
//using namespace std;
//#define MAX 200001
//#define INF 99999999
//typedef struct XNode
//{
//    int pow;    // 边的权值
//    int adjvex; // 点
//    struct XNode *next; 
//}Node;
//Node * head[MAX];
//int visit[MAX],dis[MAX];
//void add(int u,int v,int w)
//{
//    Node * p;
//    p = (Node *)malloc(sizeof(Node));
//    p->pow=w;
//    p->adjvex=v;
//    p->next=head[u];
//    head[u]=p;
//
//}
//void SPFA(int n)
//{
//    int u,v,w;
//    queue<int>Q;    // 这个算法关键使用队列来处理问题
//    Node *p;
//    for(int i=1;i<=n;i++)   // 初始化
//    {
//        visit[i]=0;
//        dis[i]=INF;
//    }
//    Q.push(1);  // 头结点进队
//    dis[1]=0;
//    visit[1]=1;
//    while(!Q.empty())   // 直到队列为空才结束循环
//    {
//        u=Q.front();    // 头结点
//        Q.pop();    // 进队
//        for(p=head[u];p!=NULL;p=p->next)
//        {
//            v=p->adjvex;
//            w=p->pow;
//            if(dis[u]+w<dis[v])
//            {
//                dis[v]=dis[u]+w;
//                if(!visit[v])
//                {
//                    visit[v]=1;
//                    Q.push(v);   // 出队
//                }
//            }
//        }
//    }
//}
//
//int main()
//{
//    int n,m,u,v,w;
//    while(cin >> n >> m)
//    {
//        memset(head,NULL,sizeof(head));
//        for(int  i=1;i<=m;i++)
//        {
//            scanf("%d%d%d",&u,&v,&w);
//            add(u,v,w);
//        }
//        SPFA(n);
//        for(int i=2;i<=n;i++)
//            cout << dis[i] << endl;
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//#include<string>
//int main()
//{
//    char buf[1000];
//    string str;
//    int len=0,sum=0;
//    while(cin >> str)
//    {
//        sum += str.length();
//        len++;
//    }
//    cout << (float)sum / len << endl; 
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//    int n=0,a[100]={0},x,max=0;
//    while(cin >> x)
//    {
//        if(++a[x]>max)  max=a[x];
//        if(x>n) n=x;
//    }
//    for(int i=0;i<=n;i++)
//    {
//        if(a[i]==max)
//            cout << i << "  " ;
//    }
//    return 0;
//}

//#include<iostream>
//#include<string>
//#include<>
//using namespace std;
//int main()
//{
//    
//    return 0;
//}


//#include<iostream>
//#include<cstdio>
//#include<cstdlib>
//#include<cctype>
//using namespace std;
//int main()
//{
//  int a=0;
//  long long ans=1;
//  char c;
//  while((c=getchar())!=EOF) 
//    {
//      if(isdigit(c)) a=a*10+c-'0';
//      else if(c==' ') {ans*=a; a=0;}
//      if(ans==0) break;
//  }
//  ans*=a;
//  printf("%3lld\n",ans%1000);



//#include<iostream>
//#include<cstdio>
//#include<cstdlib>
//#include<cctype>
//using namespace std;
//int main()
//{
//  int a=0;
//  long long ans=1;
//  char c;
//  while((c=getchar())!='\n') 
//    {
//      if(isdigit(c)) a=a*10+c-'0';
//      else if(c==' ') {ans*=a; a=0;}
//      if(ans==0) break;
//  }
//  ans*=a;
//    //printf("%lld",ans);
//    if(ans<1000)    
//        printf("%3lld\n",ans);
//    else
//      printf("%3lld\n",ans%1000);
//  return 0;
//}

//#include<iostream>
//#include<stdio.h>
//using namespace std;
//int main()
//{
//    int a,b;
//    char c;
//    scanf("%d",a);
//    c= getchar();
//    while(c!='+' && c!='-' && c!='*')
//        c = getchar();
//  scanf("%d",&b);
// int ans;
// if(c=='+') ans=a+b;
// else if(c=='-') ans=a-b;
// else if(c=='*') ans=a*b;
// printf("%d %c %d = %d",a,c,b,ans);
//    return 0;
//}

//#include<iostream>
//#include<cstdio>
//using namespace std;
//int main()
//{
// int a,b;
// char c;
// //freopen("calculator.in","r",stdin);
// //freopen("calculator.out","w",stdout);
// scanf("%d",&a);
// c=getchar();
// while(c!='+'&&c!='-'&&c!='*') c=getchar();
// scanf("%d",&b);
// int ans;
// if(c=='+') ans=a+b;
// else if(c=='-') ans=a-b;
// else if(c=='*') ans=a*b;
// else ans=0;
// printf("%d %c %d = %d",a,c,b,ans);
// return 0;
//}


//#include <stdio.h>
//#define N 4
//char m[N][N]= {
//    {'a', 'b', 'c', 'd'},
//    {'e', 'f', 'g', 'h'},
//    {'i', 'j', 'k', 'l'},
//    {'m', 'n', 'o', 'p'}
//};
// 
//int main(){
//    int i, j;
//    for(i=0; i<N; ++i){
//        for(j=0; j<N; ++j)
//            printf("%c ", m[j][N-1-i]);
//        printf("\n");
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int str[4][4]
//     = {1,2,3,4,
//        5,6,7,8,
//        9,10,11,12,
//        13,14,15,16};
//    for(int i=0;i<4;i++)
//    {
//        for(int j=0;j<4;j++)
//        {
//            cout << str[j][3-i] << " " ;
//            
//        }
//        cout << endl;
//    }
//    return 0;
//}


//
//
///**************************************************************************************
//*                   动态数码管显示实验                                               *
//实现现象:下载程序后数码管从右至左显示0-7。
//注意事项:如果不想让点阵模块显示,可以将74HC595模块上的JP595短接片拔掉。                                                                                  
//***************************************************************************************/
//
//#include "reg52.h"             //此文件中定义了单片机的一些特殊功能寄存器
//
//typedef unsigned int u16;   //对数据类型进行声明定义
//typedef unsigned char u8;
//
//sbit LSA=P2^2;
//sbit LSB=P2^3;
//sbit LSC=P2^4;
//
//u8 code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
//                  0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//显示0~F的值
//
///*******************************************************************************
//* 函 数 名         : delay
//* 函数功能           : 延时函数,i=1时,大约延时10us
//*******************************************************************************/
//void delay(u16 i)
//{
//  while(i--); 
//}

/*******************************************************************************
* 函 数 名         : DigDisplay
* 函数功能         : 数码管动态扫描函数,循环扫描8个数码管显示
*******************************************************************************/
//void DigDisplay()
//{
//  u8 i;
//  for(i=0;i<8;i++)
//  {
//      switch(i)    //位选,选择点亮的数码管,
//      {
//          case(0):
//              LSA=0;LSB=0;LSC=0; break;//显示第0位
//          case(1):
//              LSA=1;LSB=0;LSC=0; break;//显示第1位
//          case(2):
//              LSA=0;LSB=1;LSC=0; break;//显示第2位
//          case(3):
//              LSA=1;LSB=1;LSC=0; break;//显示第3位
//          case(4):
//              LSA=0;LSB=0;LSC=1; break;//显示第4位
//          case(5):
//              LSA=1;LSB=0;LSC=1; break;//显示第5位
//          case(6):
//              LSA=0;LSB=1;LSC=1; break;//显示第6位
//          case(7):
//              LSA=1;LSB=1;LSC=1; break;//显示第7位    
//      }
//      P0=smgduan[i];//发送段码
//      delay(100); //间隔一段时间扫描  
//      P0=0x00;//消隐
//  }
//}
//
///*******************************************************************************
//* 函 数 名       : main
//* 函数功能         : 主函数
//* 输    入       : 无
//* 输    出       : 无
//*******************************************************************************/
//void main()
//{ 
//  while(1)
//  {   
//      DigDisplay();  //数码管显示函数    
//  }       
//}

//
//#include<iostream>
//using namespace std;
//int main()
//{
//    int str[100]={0},top=0;
//    int n,x,b;
//    cin >> b >> x;
//    while(x)
//    {
//        str[++top] = x%b;
//        x = x/b;
//
//    }
//    while(top)  cout << str[top--] << endl;
//    return 0;
//}



//#include<iostream>
//#include<cstdio>
//using namespace std;
//int main()
//{
//
// int b,n,x;
// cin >> b >> n;
// //10进制转n进制
// x=n;
// int s[100]={0},top=0;
// while(x)
// {
//      s[++top]=x%b;
//      x/=b;
// }
// while(top) cout << s[top--];
// return 0;
//}

//#include<iostream>
//#include<cmath>
//using namespace std;
//int main()
//{
//    int str[100] = {0},b=0,ans=0,top=0;
//    char c; 
//    cin >> b;
//    cout << "Hello" << endl;
//    while(cin >> c)     str[++top] = c - '0';
//    int i=0;
//    while(top)  ans += str[top--] * pow(b,i++);
//    cout << ans << endl;
//    return 0;
//}


//#include<stdio.h>
//int main()
//{
//    char c ;
//    while((c = getchar()) != EOF)
//        printf("%c",c);
//    return 0;
//}


//#include<iostream>
//#include<stdio.h>
//#include<stdlib.h>
//#include<string.h>
//int n;
//char word[2000][10],sorted[2000][10];
//// 字符比较函数
//int cmp_char(const void* _a,const void* _b)
//{
//    char* a = (char*)_a;
//    char* b = (char*)_b;
//    return *a-*b;
//}
//// 字符串比较函数
//int cmp_string(const void* _a,const void* _b)
//{
//    char* a = (char*)_a;
//    char* b = (char*)_b;
//    return strcmp(a,b);
//}
//int main()
//{
//    n=0;
//    for(;;)
//    {
//        scanf("%s",word[n]);
//        if(word[n][0] == '*') break;    //遇到结束标志符就终止循环
//        n++;
//    }
//    qsort(word,n,sizeof(word[0]),cmp_string);   //给所有单词排序
//    for(int i=0;i<n;i++)
//    {
//        strcpy(sorted[i],word[i]);
//        qsort(sorted[i],strlen(sorted[i]),sizeof(char),cmp_char);   //给每个单词排序
//    }
//    char s[10];
//    while(scanf("%s",s) == 1)   // 持续读到未见末尾
//    {
//        qsort(s,strlen(s),sizeof(char),cmp_char);   // 给输入单词排序
//        int found=0;
//        for(int i=0;i<n;i++)
//            if(strcmp(sorted[i],s) == 0)
//            {
//                found=1;
//                printf("%s",word[i]);   // 输出原始单词 而不是排序后的
//            }
//            if(!found)  printf(":(");
//            printf("\n");
//    }
//    return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//int main()
//{
//    FILE * fp;
//    int ch;
//
//    if((fp=fopen("myfile","r"))==NULL )
//    {
//        printf("The file can not be open .\n");       
//    }
//    ch=fgetc(fp);
//    while(ch!=EOF)
//    {
//        putchar(ch);
//        ch=fgetc(fp);
//    }
//    fclose(fp);
//    return 0;
//}






//#include <stdio.h>   
//#include <stdlib.h>  
//int main() {   
//    FILE *fp;   
//    char ch;  
//    if((fp=fopen("myfile.txt","r"))==NULL) {  
//        printf("file cannot be opened/n");   
//        exit(1);   
//    }   
//    while((ch=fgetc(fp))!=EOF)   
//        fputc(ch,stdout);   
//    fclose(fp);   
//}



//#include <stdio.h> 
//#include <stdlib.h> 
//#include <memory.h>
//#include <string.h> 
//#include <assert.h>
//#define MAX_LENGTH 1000
//int main(void)
//{
//FILE * fp = fopen("d:\\a.txt", "r");
//long int pos;
//char * str = (char *)malloc(MAX_LENGTH);
//assert(str);
//errno = 0;
//if(!fp)
//{
//fprintf(stderr,
//"open d: \a.txt failed. Error code: %s\n", strerror(errno));
//return -1;
//}
//    return 0;
//}

// 这个是大有问题啊
//#include<stdio.h>
//#include<stdlib.h>
//int main()
//{
//    FILE *fp;  
//    if((fp=fopen("myfile.txt","r"))==NULL) {  
//        printf(" File cannot be opened \n");  // 应该会打印这一行啊
//        exit(1);
//    }  
//    else  
//        printf("File opened for writing \n");  
//    
//    char ch;
//    ch=fgetc(fp);
//    while(ch!=EOF)
//    {
//        putchar(ch);
//        ch=fgetc(fp);
//    }
//    fclose(fp); 
//
//    FILE * out = fopen("myfile","w");
//    fputc('s',out);
//    fclose(out);
//}


//#include<iostream>
//using namespace std;
//#include<stdio.h>
//#include<stdlib.h>
//int main()
//{
//    FILE * fp = fopen("myfile.txt","rb");
//    /*int i,sum=0;*/
//    /*for(i=0;i<10;i++)
//    {
//        sum+=getw(fp);
//    }
//    printf("%d\n",sum);*/
//    printf("%0x",fgetc(fp));
//
//    fclose(fp);
//    return 0;
//}

//#include<iostream>  
//using namespace std;  
//int gcd(int a,int b)  
//{  
//    if(a<b) {cout << "运行第一个if" << endl;
//    swap(a,b);  }
//    if(b){ cout << "运行第二个if" << endl;
//        return gcd(b,a%b);  }
//    return a;  
//}  
//int main()  
//{  
//    int a,b,c;
//    cin >> a >> b ;
//  
//    
//    cout << "gcd(a,b)" << gcd(a,b) << endl;
//    /*int a,b,c;  
//    while(cin>>a>>b>>c){  
//        int lcm=a*b/gcd(a,b);  
//        cout << "gcd(a,b)" << gcd(a,b) << endl;
//        cout << "lcm = " << lcm << endl;
//        lcm=lcm*c/gcd(lcm,c);  
//        cout<<lcm<<endl;  
//    }  */
//    return 0;  
//}  


//#include<iostream>  
//#include<algorithm>  
//#include<cstdio>  
//#include<cstring>  
//#define LL long long  
//#define MAXN 1000100  
//using namespace std;  
//int gcd(int a,int b)  
//{  
//    int t,r;  
//    if(a<b)  
//    {  
//        t=a;  
//        a=b;  
//        b=t;  
//    }  
//    r=a%b;  
//    while(r)  
//    {  
//          
//        a=b;  
//        b=r;  
//        r=a%b;  
//    }  
//    return b;  
//}  
//int main()  
//{  
//    cout << "ok" << endl;
//    int a,b,c;  
//    while(cin>>a>>b>>c)  
//    {  
//        int t1=a*b/gcd(a,b);  
//        int t2=b*c/gcd(b,c);  
//        int ans=t1*t2/gcd(t1,t2);  
//        cout<<ans<<endl;  
//     }   
//    return 0;  
//}


//#include<iostream>
//using namespace std;
//int gcd(int a,int b)
//{
//    if(a<b) swap(a,b);
//    if(b)   return gcd(b,a%b);
//    return a;
//}
//int main()
//{
//    int a,b,c;
//    cin >> a >> b >> c;
//    int temp = a*b/gcd(a,b);
//    temp = temp*c/gcd(temp,c);
//    cout << temp << endl;
//    return 0;
//}


//#include<stdio.h>  
//#include<string.h>  
//#include<stdlib.h>  
//#include<time.h>  
//int aws=0;  
//int a[10],flag[10];  
//int sum(int start,int end)  
//{  
//     int i,sum=0;    
//     for(i=start;i<end;i++)   
//     sum=sum*10+a[i+1];    
//     return sum;   
//}  
//void Found(int a[],int n,int m)//将DFS中的每一个全排列结果放在Found函数中检验  
//{  
//     int i,j,begin=0;  
//     for(i=1;i<n;i++)  
//     {  
//        int m1=sum(0,i);//第一个数从1至9开始选   
//        if(m1>=m) return;//不满足第一个数<m的直接淘汰   
//        for(j=i+(n-i)/2;j<n-1;j++)  
//        {  
//           int m2=sum(i,j);//第二个数   
//           int m3=sum(j,n-1);//第三个数   
//           if(m2>m3&&m2%m3==0&&m==m1+m2/m3)  
//           {  
//              //printf("%d=%d+%d/%d\n",m,m1,m2,m3);  
//              aws++;  
//           }  
//        }  
//     }  
//}  
//void DFS(int start,int n,int m)//对1~9进行全排列   
//{  
//     int i;  
//     if(start==n)  
//     Found(a,n,m);  
//     else  
//     {  
//         for(i=1;i<n;i++)  
//         {  
//            if(flag[i])   
//            continue;    
//            a[start]=i;    
//            flag[i]=1;    
//            DFS(start+1,n,m);//选择好一位开始选下一位   
//            flag[i]=0;  
//         }  
//     }  
//}  
//int main()  
//{  
//    int i,j,m;  
//    double s1,s2;  
//    memset(flag,0,sizeof(flag));  
//    scanf("%d",&m);  
//    //s1=clock();   
//    DFS(1,10,m);  
//    //s2=clock();   
//    printf("%d\n",aws);  
//    //printf("%.0lfms\n",s2-s1);  
//    //system("pause");  
//    return 0;  
//}  


//#include<stdio.h>
//#include<string.h>
//// 素数判定 注意 n不能太大
//int is_prime(int n)
//{
//    for(int i=2;i*i<=n;i++)
//        if(n%i==0)  return 0;
//    return 1;
//}
//
//// 素数表
//int prime[100],count=0;
//int main()
//{
//    // n和各个素数的指数
//    int n,p[100];
//
//    // 构造素数表
//    for(int i=2;i<=100;i++)
//        if(is_prime(i)) prime[count++]=i;
//
//    while(scanf("%d",&n)==1)
//    {
//        printf("%d! =",n);
//        memset(p,0,sizeof(p));
//        int maxp=0;
//        for(int i=1;i<=n;i++)
//        {
//            // 必须把i复制到变量m中 而不要在做除法是直接修改它
//            int m=i;
//            for(int j=0;j<count;j++)
//                while(m%prime[j]==0)    //反复除以prime[j] 并累加p[j]
//                {
//                    m/=prime[j];
//                    p[j]++;
//                    if(j>maxp)  maxp=j;     //更新最大素因子下标
//                }
//        }
//        //只循环到最大下标
//        for(int i=0;i<=maxp;i++)
//            printf(" %d",p[i]);
//        printf("\n");
//        printf("maxp的值是 %d",maxp);
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//double area2(double x0,double y0,double x1,double y1,double x2,double y2)
//{
//    return abs(x0*y1+x2*y0+x1*y2-x2*y1-x0*y2-x1*y0);
//}
//
//int main()
//{
//    double x0,y0,x1,y1,x2,y2;
//    while(cin>>x0>>y0>>x1>>y1>>x2>>y2)
//    {
//        double area=area2(x0,y0,x1,y1,x2,y2);
//        int count=0;
//        const double eps=1e-9;
//        for(int i=1;i<=99;i++)
//            for(int j=1;j<=99;j++)
//            {
//                double a1,a2,a3;
//                a1=area2(i,j,x0,y0,x1,y1);
//                a2=area2(i,j,x0,y0,x2,y2);
//                a3=area2(i,j,x1,y1,x2,y2);
//                if(fabs(a1+a2+a3-area)<eps)
//                    count++;
//            }
//        cout << count << endl;
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//#include<string.h>
//#include<stack>
//char str[1000];
//
//int main()
//{
//    int n ;
//    stack <char> temp;
//    cin >> n;
//    while(n--)
//    {
//        cin >> str;
//        int len = strlen(str);
//        int flag=0;
//        for(int i=0;i<len;i++)
//        {
//            if(str[i]=='(' || str[i]=='[' || str[i]=='{')
//                temp.push(str[i]);
//            if(str[i] == ')')
//            {
//                if(temp.empty())
//                    {flag=0;break;}
//                 if('(' != temp.top())
//                    {flag=0;break;}
//                 else 
//                    {temp.pop();flag=1;}
//            }   
//
//            if(str[i] == ']')
//            {
//                if(temp.empty())
//                   {flag=0;break;}
//                 if('[' != temp.top())
//                   {flag=0;break;}
//                 else 
//                 {temp.pop();flag=1;}
//            }
//            if(str[i] == '}')
//            {
//                if(temp.empty())
//                    {flag=0;break;}
//                 if('{' != temp.top())
//                    {flag=0;break;}
//                 else 
//                 {temp.pop(); flag=1;}
//            }
//
//
//        }
//        if(temp.empty())
//            cout << "Yes" <<endl;
//        else
//        {
//            cout << "No" <<endl;
//        }
//    }
//    return 0;
//}
//


//称硬币问题
//#include<iostream>
//#include<cstring>
//using namespace std;
//char Right[3][7];  //天平左边硬币
//char Left[3][7];    //天平右边硬币
//char result[3][7];  //结果
//bool IsFake(char c,bool light);
////light 为真表示假设硬币为轻 否则表示硬币为重
//
//int main()
//{
//    int t;
//    cin >> t;
//    while(t--)
//    {
//        for(int i=0;i<3;i++)
//        {
//            cin >> Left[i] >> Right[i] >> result[i] ;
//            for(char c='A';c<='L';c++){
//                if(IsFake(c,true))
//                {
//                    cout << c <<" is the counterfeit coin and it is light \n";
//                    break;
//                }
//                if(IsFake(c,false)) 
//                {
//                    cout << c << "is the counterfeit coin and it is heavy \n";
//                    break;
//                }
//                
//            }
//
//        }
//    }
//}
//bool IsFake(char c,bool light)
//{
//    for(int i=0;i<3;i++)
//    {
//        char * pLeft,*pRight;
//        if(light)
//        {
//            pLeft = Left[i];
//            pRight = Right[i];
//        }
//        else 
//        {
//            pLeft = Right[i];
//            pRight = Left[i];
//        }
//        switch(result[i][0])    // 天平右边情况
//        {
//            case 'u':
//                if(strchr(pRight,c)==NULL)
//                    return false;
//                break;
//            case 'e':
//                if(strchr(pLeft,c) || strchr(pRight,c))
//                    return false;
//                break;
//            case 'd':
//                if(strchr(pRight,c))
//                    return false;
//                break;
//        }
//
//    }
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//    for(int i=1;i<=5;i++) {
//        switch(i) {
//        case 1:
//            cout << i << endl;
//            break;
//        case 2:
//            cout << i << endl;
//            break;
//        case 3:
//            cout << i << endl;
//            break;
//        case 4:
//            cout << i << endl;
//            break;
//        case 5:
//            cout << i << endl;
//            break;
//
//
//        }
//    }
//    return 0;
//
//}


//#include<iostream>
//#include<cstdio>
//#include<cmath>
//
//using namespace std;
//
//int main()
//{
//    int T,n;
//    double s,tmp,x1,x2,y1,y2,tx,ty,Gx,Gy;
//    scanf("%d",&T);
//    while(T--)
//    {
//        s = Gx = Gy = 0;
//        scanf("%d",&n);
//        if(n>1)
//        {
//            scanf("%lf%lf",&x1,&y1);
//            tx = x1;
//            ty = y1;
//            n--;
//            while(n--)
//            {
//                scanf("lf%lf",&x2,&y2);
//                tmp = (x1*y2-y1*x2)/2; //计算各个三角形的有向面积
//                Gx += tmp*(x1+x2)/3.0; //计算每个三角形的重心的横纵坐标并已该三角形的有向面积作为权重
//                Gy += tmp*(y1+y2)/3.0;
//                s += tmp;
//                x1 = x2;
//                y1 = y2;
//
//            }
//            tmp = (x1*ty-y1*ty)/2;
//            Gx += tmp*(x1+tx)/3.0;
//            Gy += tmp*(y1+ty)/3.0;
//            s += tmp;
//        }
//        if(fabs(s) < 10e-4)
//            printf("0.000  0000\n");
//        else
//            printf("%.3lf %.3lf\n",fabs(s),(Gx+Gy)/s);//注意是有向的
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int count = 0;
//    for(int a=1;a<=9;a++)
//        for(int b=0;b<=9;b++)
//            for(int c=0;c<=9;c++)
//                for(int d=0;d<=9;d++)
//                    for(int e=0;e<=9;e++)
//                        if(a!=4 && b!=4 &&c!=4 && d!=4 && e!=4)
//                            count++;
//    cout << count << endl;
//    
//    return 0;
//}



//#include<iostream>
//using namespace std;
//
//int main()
//{
//    int queue[50];
//    for(int i=0;i<50;i++) 
//    {
//        queue[i] = i+1;
//    }
//    int front = 0;
//    int rear = 50;
//    while(front<rear)
//    {
//        cout << queue[front++] << endl;
//        cout << front << endl;
//        queue[rear++] = queue[front++];
//        cout << front << endl;
//    }
//    
//    return 0;
//}

//#include<iostream>
//using namespace std;
//#include<queue>
//
//queue<int> q;
//int main()
//{
//    int n;
//    cin >> n;
//    for(int i=0;i<n;i++) q.push(i+1);
//    while(!q.empty())
//    {
//        cout << q.front() << endl;
//        q.pop();
//        if(q.empty())
//            break;
//        q.push(q.front());
//        q.pop();
//    }
//    return 0;
//}


//#include<iostream>
//using namespace std;
//const int MAXN = 1000 + 10;
//int n,target[MAXN];
//int main()
//{
//    while(cin >> n)
//    {
//        int stack[MAXN],top=0;
//        int A = 1,B = 1;
//        for(int i=1; i<=n;i++) 
//        {
//            cin >> target[i];
//        }
//        int ok = 1;
//        while(B <= n)
//        {
//            if(A == target[B])
//            {
//                A++;B++;
//            }
//            else if(top && stack[top] == target[B]) 
//            {
//                top--;B++;
//            }
//            else if(A <= n)
//                stack[++top] = A++;
//            else 
//            {
//                ok=0;break;
//            }
//            cout << ok ? "YES" : "NO" << endl;
//        }
//    }
//    
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int arr[35][35];
//
//int main()
//{
//    int n;
//    
//    cin >> n;
//    for(int i=0;i<n;i++)
//    {
//        arr[i][0] = arr[i][i] = 1;
//        for(int j=0;j<i;j++) 
//            arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
//        cout << endl;
//        for(int j=0;j<=i;j++)
//            cout << arr[i][j] << " " ;           
//    }
//
//    for(int i=0;i<5;i++) 
//    {
//        for(int j=0;j<i;j++)
//        {
//            cout << arr[i][j] << " " ;
//        }
//        cout << endl;
//    }
//    cout << endl;
//      for(int i=0;i<5;i++) 
//    {
//        for(int j=0;j<=i;j++)
//        {
//            cout << arr[i][j] << " " ;
//        }
//        cout << endl;
//    }
//
//      cout << arr[0][-1];
//    return 0;
//
//}

//#include<iostream>
//using namespace std;
//char OX[10000];
//int main()
//{
//    long long num,k;
//    cin >> num;
//    int i;
//    while(num/16>0)
//    {
//        i=0;
//        k = num%16;
//        if(k>=0 && k<=9)
//        {
//            OX[i] = char('0'+ k);
//
//        }
//        else if(k>=10 && k<=15)
//            OX[i] = char('A'+k-10);
//        num/=16;
//        i++;
//    }
//     k=num%16;  
//        if( k>=0 && k<=9 )  
//            OX[i]=char('0'+k);  
//        else if(k>=10 && k<=15)  
//            OX[i]=char('A'+k-10);  
//    for(k=i;k>=0;k--)
//        cout << OX[i] ;
//    cout << endl;
//    
//    return 0;
//}

//#include <iostream>  
//  
//using namespace std;  
//  
//long long num,k;  
//char arr[10000001];  
//int main()  
//{  
//    int i;  
//    while(cin>>num)  
//    {  
//        i=0;  
//        while(num/16>0)  
//        {  
//            k=num%16;  
//            if( k>=0 && k<=9 )  
//                arr[i]=char('0'+k);  
//            else if(k>=10 && k<=15)  
//                arr[i]=char('A'+k-10);  
//            num/=16;  
//            ++i;  
//        }  
//        k=num%16;  
//        if( k>=0 && k<=9 )  
//            arr[i]=char('0'+k);  
//        else if(k>=10 && k<=15)  
//            arr[i]=char('A'+k-10);  
//  
//        for(k=i;k>=0;--k)  
//            cout<<arr[k];  
//        cout<<endl;  
//    }  
//    return 0;  
//}  

//#include<iostream>
//#include<string>
//using namespace std;
//#include<cmath>
//int main()
//{
//    string str;
//    cin >> str;
//    int len = str.length();
//    int sum = 0;
//    for(int i=len-1;i>=0;i--) 
//    {
//        if(str[i]>='0' && str[i] <= '9')
//            sum += pow(16,len-1-i) * (str[i]-'0');
//        else if(str[i]>= 'A' && str[i] <= 'F')
//            sum += pow(16,len-1-i) * (str[i] - 'A' + 10);
//    }
//    cout << sum ;
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int arr[100000];
//#include<string>
//int main()
//{
//    string str,str2;
//    cin >> str;
//    int len_str = str.length();
//   for(int i=0;i<len_str;i++)
//   {
//     switch (str[i])
//    {     
//        case '1':str2+="0001";break;  
//        case '2':str2+="0010";break;  
//        case '3':str2+="0011";break;  
//        case '4':str2+="0100";break;  
//        case '5':str2+="0101";break;  
//        case '6':str2+="0110";break;  
//        case '7':str2+="0111";break;  
//        case '8':str2+="1000";break;  
//        case '9':str2+="1001";break;  
//        case 'A':str2+="1010";break;  
//        case 'B':str2+="1011";break;  
//        case 'C':str2+="1100";break;  
//        case 'D':str2+="1101";break;  
//        case 'E':str2+="1110";break;  
//        case 'F':str2+="1111";break;  
//    default:
//        break;
//    }
//   }
//   cout << "str2=" <<  str2 << endl;
//   int len_str2 = str2.length();
//   
//   if(len_str2 %3 == 1)     str2 = "00" + str2;
//   else if(len_str2 % 3 == 2)   str2 = "0" + str2;  
//
//   cout << "str2补全 " << str2 << endl;
//
//   int j;
//   int i=0;
//   for(j=0;j<len_str2-2;j+=3)
//   {
//        arr[i] += (str2[j]-'0')*4 + (str2[j+1]-'0')*2 + (str2[j+2]-'0');       
//        i++;
//   }
//   cout << str2[4] << endl;
//   cout << (str2[4]-'0') *2 << endl;
//   /*for(int m=0;m<i;m++)*/
//       cout << arr[1] ;
//   
//    return 0;
//}



//#include <iostream>  
//#include <string>  
//using namespace std;  
//int arr[10000001];  
//  
//  
//int main()  
//{  
//int n,len_str,i,j;  
//string str,str2;  
//cin>>n;  
//while(n--)  
//{  
//cin>>str;  
//len_str=str.length();  
//str2="";  
//  
//  
//// 十六进制转换为二进制  
//for(i=0;i<len_str;++i)  
//{  
//switch(str[i])  
//{  
//case '0':str2+="0000";break;  
//case '1':str2+="0001";break;  
//case '2':str2+="0010";break;  
//case '3':str2+="0011";break;  
//case '4':str2+="0100";break;  
//case '5':str2+="0101";break;  
//case '6':str2+="0110";break;  
//case '7':str2+="0111";break;  
//case '8':str2+="1000";break;  
//case '9':str2+="1001";break;  
//case 'A':str2+="1010";break;  
//case 'B':str2+="1011";break;  
//case 'C':str2+="1100";break;  
//case 'D':str2+="1101";break;  
//case 'E':str2+="1110";break;  
//case 'F':str2+="1111";break;  
//default:break;  
//}  
//}  
//  
//// 修正位数,这里用十六进制的长度来对3取余,其实用2进制的  
////长度也是一样的,因为1个16进制对应4个二进制,所以取余效果是相同的  
//if(len_str%3==1)str2="00"+str2;  
//  
//else if(len_str%3==2)str2="0"+str2;  
//  
//  
//  
//len_str=str2.length();  
//// 二进制转换八进制  
//j=0;  
//for(i=0;i<=len_str-2;i+=3)  
//{  
//arr[j]=(str2[i]-'0')*4+(str2[i+1]-'0')*2+(str2[i+2]-'0');  
//++j;  
//}  
//  
//  
//for(i=0;i<j;++i)  
//{  
//if(i==0 && arr[i]==0)continue;  
//cout<<arr[i];  
//}  
//cout<<endl;  
//  
//  
//}  
//return 0;  
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//    int arr[100];
//    int len = 5;
//    for(int i=0;i<len;i++)
//        cin >> arr[i];
//    for (int i=0;i<len-1;i++)
//        for(int j=0;j+1<=len-i;j++)
//        {
//            if(arr[j]>arr[j+1])
//            {
//                int temp = arr[j];
//                arr[j] = arr[j+1];
//                arr[j+1] = temp;
//            }
//        }
//    
//        cout  << arr[1] /*<< arr[2] << arr[3] << arr[4] << arr[5]*/;
//    
//    return 0;
//}


// 数组排列
//#include<iostream>
//#include<algorithm>
//using namespace std;
//int arr[100001];
//int main()
//{
//    int n;
//    while(cin >> n)
//    {
//        for(int i=0;i<n;i++)
//            cin >> arr[i];
//       /* sort(arr,arr+n);
//        for(i=0;i<n;i++)
//        {
//            if(i==n-1)
//                cout << arr[i] << endl;
//            else 
//                cout << arr[i] << " ";
//        }*/
//
//        for(int i=0;i<n-1;i++)
//            for(int j=0;j+1<n-i;j++)
//            {
//                if(arr[j]>arr[j+1])
//                {
//                    int temp = arr[j];
//                    arr[j] = arr[j+1];
//                    arr[j+1] = temp;
//                }
//            }
//            for(int i=0;i<n;i++)
//                cout << arr[i] << " " ;
//    }
//    return 0;
//}

// K大数查询

//#include<iostream>
//#include<algorithm>
//using namespace std;
//int arr[1001],brr[1001];
//
//bool cmp(int a,int b)
//{
//    return a>b;
//}
//
//int main()
//{
//    int n,m;
//    int l,r,k;
//    int i,j;
//
//    while(cin >> n)
//    {
//        for(i=0;i<n;i++)
//            cin >> arr[i];
//        cin >> m;
//        while(m--)
//        {
//            cin >> l >> r >> k;
//            // 将相应的区间复制到另一个数组中 排序
//            for(j=l-1,i=0;j<r;++j,++i)
//                brr[i]=arr[j];
//            sort(brr,brr+i,cmp);
//            for(int q=0;q<i;q++)
//                cout << brr[q] << " " ;
//            cout << endl;
//            cout << brr[k-l] << endl;
//        }
//    }
//}


//#include<iostream>
//using namespace std;
//
//int main()
//{
//    long long n,number;
//    cin >> n;
//    if(n<=2)
//        cout << 2;
//    else if(n%2)
//    {
//        number = n*(n-1)*(n-2);
//    }
//    else if(n%3)
//            number = (n-1)*(n-2)*(n-3);
//    else
//    {
//        number = n*(n-1)*(n-2);
//    } 
//    return 0;
//}

//#include<iostream>
//#include<stack>
//using namespace std;
//const int MAXN = 1000 + 10;
//int n,target[MAXN];
//int ok = 1;
//int main()
//{
//    while(cin >> n)
//    {
//        stack<int>s;
//        int A =1, B=1;
//        for(int i=1;i<=n;i++)
//            cin >> target[i];
//       
//        while(B<=n)
//            if(A == target[B]){A++;B++;}
//            else if(!s.empty() && s.top() ==target[B]){s.pop();B++;}
//            else if(A<=n) s.push(A++);
//            else {ok=0;break;}
//    }
//  if(ok)
//      cout << "yes" << endl;
//  else 
//      cout << "no" << endl;
//}

//
//#include<iostream>
//#include<string.h>
//using namespace std;
//const int MAXD = 20;
//int s[1<<MAXD];     //最大节点个数为 
//int main()
//{
//    int D,I;
//    while(cin >> D >> I)
//    {
//        memset(s,0,sizeof(s));  //开关
//        int k,n=(1<<D)-1;   //n是最大的节点编号
//        for(int i=0;i<I;i++)  // 连续让I个小求下落
//        {
//            k=1;
//            for(;;)
//            {
//                s[k]=!s[k];
//                k=s[k]?k*2:k*2+1;   // 根据开关状态选择下落方向
//                if(k>n) break;  //已经出界了
//            }
//        }
//        cout<< k/2 << endl; // 出界之前的叶子编号
//    }
//    
//    return 0;
//}


//九数组分数

//1,2,3...9 这九个数字组成一个分数,其值恰好为1/3,如何组法?

//下面的程序实现了该功能,请填写划线部分缺失的代码

//#include <stdio.h>
//#include<iostream>
//using namespace std;
//
//void test(int x[])
//{
//  int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
//  int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];
//  
//  if(a*3==b) printf("%d / %d\n", a, b);
//}
//
//void f(int x[], int k)
//{
//  int i,t;
//  if(k>=9){
//      test(x);
//        
//      return;
//  }
//  
//  for(i=k; i<9; i++){
//      {t=x[k]; x[k]=x[i]; x[i]=t;}
//      f(x,k+1);
//      {t=x[k]; x[k]=x[i]; x[i]=t;}  // 填空处
//  }
//}
//  
//int main()
//{
//  int x[] = {1,2,3,4,5,6,7,8,9};
//  f(x,0); 
//  return 0;
//}

//#include<iostream>
//using namespace std;
//int main() 
//{
//    int sum=1225;
//    int temp=0,res=0,i,j;
//    for(i=1;i<=46;i++) 
//    {
//         temp = res = sum-(i+1+1)+i*(i+1);
//          for( j=i+2;j<=48;j++) 
//          {
//            res = temp-(j+j+1)+j*(j+1);
//            //cout << "第二重循环" << endl;
//            if(res==2015)
//                cout << i <<endl;
//          }
//    }
//    return 0;
//}




//#include <stdio.h>    
//int main()    
//{    
//    int sum = 1225;  
//    int tmp=0;  //临时变量,在程序中保存中间结果   
//    int res=0;  //用来保存将“+”改变成“*”号后的结果   
//    for(int i=1; i<=46; ++i)  
//     {    
//        tmp = res = sum-(i+(i+1))+i*(i+1);    
//          
//        for(int j=i+2; j<=48; ++j)   
//        {    
//            res = tmp-(j+(j+1))+j*(j+1);    
//            if(res == 2015)  
//            {    
//                printf("(i= %d ,j= %d)\n", i,j);    
//            }      
//        }    
//    }    
//}  

//#include<iostream>
//using namespace std;
//int main()
//{
//    int sum = 1225;
//    int temp,res;
//    int i,j;
//    for(i=1;i<=46;i++)
//    {
//        temp = res = sum-(i+i+1)+i*(i+1);
//        /* temp = res = sum-(i+(i+1))+i*(i+1);*/
//        for(j=i+2;j<=48;j++)
//        {
//            res = temp-(j+j+1)+j*(j+1);
//            /*res = temp-(j+(j+1))+j*(j+1); */   
//            if(res == 2015)
//                cout << i << "  " << j << endl;
//        }
//    }
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int i,j;
//    int count=0;
//    for(i=1;i<=5;i++)
//        for(j=1;j<=5;j++)
//        {
//            cout << count << endl;
//            cout << i << "  " << j << endl;
//        }
//    return 0;
//}


//#include<iostream>
//#include<cstdio>
//using namespace std;
//int main()
//{
//  int a[13];
//  int count=0;
//  for(a[0]=0; a[0]<=4; a[0]++)  
//               
//                    for(a[1]=0; a[1]<=4; a[1]++)  
//                    {  
//                        for(a[2]=0; a[2]<=4; a[2]++)  
//                        {  
//                            for(a[3]=0; a[3]<=4; a[3]++)  
//                            {  
//                                for(a[4]=0; a[4]<=4; a[4]++)  
//                                {  
//                                    for(a[5]=0; a[5]<=4; a[5]++)  
//                                    {  
//                                        for(a[6]=0; a[6]<=4; a[6]++)  
//                                        {      
//                                            for(a[7]=0; a[7]<=4; a[7]++)  
//                                            {  
//                                                for(a[8]=0; a[8]<=4; a[8]++)  
//                                                {  
//                                                    for(a[9]=0; a[9]<=4; a[9]++)  
//                                                    {  
//                                                        for(a[10]=0; a[10]<=4; a[10]++)  
//                                                        {  
//                                                            for(a[11]=0; a[11]<=4; a[11]++)  
//                                                            {  
//                                                                for(a[12]=0; a[12]<=4; a[12]++)  
//                                                                {  
//                                                                    if(a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7]+a[8]+a[9]+a[10]+a[11]+a[12]==13)  
//                                                                    {  
//                                                                        count++;                                                                     
//                                                                    }  
//                                                                  
//                                                                }  
//                                                            }  
//                                                        }  
//                                                    }  
//                                                }  
//                                            }  
//                                        }  
//                                    }      
//                                }  
//                            }  
//                        }  
//                    }  
//                    printf("%d",count);
//                  return 0;
//}


//#include <iostream>  
//using namespace std;  
//// arr为排列方式数组   
//int arr[11],sum;  
//// num为九个国家,前三个为A国设置为1,中间三个B国,设置为2,后面三个C国,设置为3   
//int num[11];  
//// a数组来表示,相应下标国家是否被选   
//int a[11];  
//void find(int n)  
//{  
//    // 人数大于4是,查找是否有连着三个相同的   
//    if(n>=4)  
//    {  
//        for(int i=1;i<=n-3;i++)  
//            if(arr[i]==arr[i+1]&&arr[i+1]==arr[i+2])  
//                return ;  
//    }  
//      
//    // n大于9,表示有一种排列可行   
//    if(n>=10)  
//    {  
//        sum++;  
//        return ;  
//    }  
//      
//    // 九次循环   
//    for(int i=1;i<=9;i++)  
//    {  
//        if(num[i]==0)  
//            continue;  
//        num[i]=0;  
//        arr[n]=a[i];  
//        find(n+1);  
//        num[i]=1;  
//    }  
//}  
//int main()  
//{  
//    sum=0;  
//    // 赋初值1,表示都没有被选过   
//    for(int i=1;i<=9;i++)  
//        num[i]=1;  
//    a[1]=a[2]=a[3]=1;a[4]=a[5]=a[6]=2;a[7]=a[8]=a[9]=3;  
//    find(1);  
//    cout<<sum<<endl;  
//    return 0;  
//}

//#include <iostream>  
//  
//using namespace std;  
//int total = 0;  
////交换函数  
//void swapArray(int &a,int &b)  
//{  
//    int temp;  
//    temp = a;  
//    a = b;  
//    b = temp;  
//}  
////递归函数  
//void fullPermutation(int * fullArray,int start,int end,int number){  
//    //这里,既可以是">=",也可以是">",,应该也可以是"=="  
//    if(start>=end){  
//        for(int i=0;i<number;i++){  
//            cout<<fullArray[i];  
//        }  
//        cout<<endl;  
//        total++;  
//    }  
//    else{  
//        for(int i=start;i<=end;i++){  
//            swapArray(fullArray[start],fullArray[i]);//交换  
//            fullPermutation(fullArray,start+1,end,number);  
//            swapArray(fullArray[start],fullArray[i]);//注意恢复原样  
//        }  
//    }  
//}  
//int main()  
//{  
//    int number;//全排列的长度  
//    cout<<"Number:"<<endl;  
//    cin>>number;  
//    int * fullArray = new int[number];//动态生成全排列的数组  
//    //初始化  
//    for (int i=0;i<number;i++)  
//    {  
//        fullArray[i] = i+1;  
//    }  
//    fullPermutation(fullArray,0,number-1,number);  
//    cout<<"Total = "<<total;  
//    return 0;  
//} 


//#include<iostream>
//#include<math.h>
//using namespace std;
//int A[10]={0};
//int main()
//{
//  int a = 25;
//  for(int i=0;i<10;i++) {
//      A[i]= a / pow(10,i)%10;     
//  }
//  cout << A[0] << " " << A[1] << endl; 
//  return 0;
//}


//#include<iostream>
//using namespace std;
//#define MAX 3000
//int main()
//{
//    int A[MAX]={0};
//    A[0]=1;
//    int n, c=0,k;
//    cin >> n;
//    for(int i=2;i<=n;i++) //乘数
//    {
//        for(int j=0;j<MAX;j++)  
//        {
//            int s = A[j]*i+c;
//            A[j] = s%10;
//            c = s/10;
//        }
//    }
//
//    for(k=MAX-1;k>=0;k--)
//        if(A[k])
//            break;
//    for(int i=k;i>=0;i--)
//        cout << A[i];
//    return 0;
//}

//#include<iostream>
//#include<string>
//using namespace  std;
//#define MAX 105
//
//void Swap(char * p)
//{
//    int i=0;
//    int len=strlen(p);
//    while( i<=(len/2))
//        swap(p[i],p[strlen(p)-1-i]);
//}
//
//int main()
//{
//    char a[MAX],b[MAX];
//    int c[MAX],a[MAX],b[MAX];
//   
//    cin>>a>>b;
//    
//       
//    
//    return 0;
//}


//
//#include<iostream>
//#include<string>
//using namespace std;
//void fun(char* p,char* q)
//{
//    int inter_a[105],inter_b[105],c[105];
//    int i,j;
//    memset(inter_a,0,sizeof(inter_a));
//    memset(inter_b,0,sizeof(inter_b));
//    memset(c,0,sizeof(c));
//    for(i=0,j=strlen(p)-1;j>=0;j--,i++)
//    {
//        inter_a[i]=p[j]-'0';
//    }
//     for(i=0,j=strlen(q)-1;j>=0;j--,i++)
//    {
//        inter_b[i]=q[j]-'0';
//    }
//     
//
//    int len = strlen(p)>strlen(q)?strlen(p):strlen(q);
//    
//    for(int i=0;i<len;i++)
//    {
//        c[i]+=inter_a[i]+inter_b[i];
//        if(c[len-1]>=10)
//            len++;
//        c[i+1]=c[i]/10;
//        c[i]=c[i]%10;        
//    }
//    for(int i=len-1;i>=0;i--)
//    {
//        cout << c[i];
//    }
//
//}
//
//int main(void)
//{
//    char a[105],b[105];
//    cin >>a>>b;
//    fun(a,b);
//    return 0;
//}



//#include<iostream>
//using namespace std;
//int arr[100];
//
//int Huffman()
//int main()
//{
//    int n;
//    cin>>n;
//    for(int i=0;i<n;i++)
//    {
//        cin >> arr[i];
//    }
//    return 0;
//}


//#include<iostream>
//#include<algorithm>
//using namespace std;
//
//int main()
//{
//    int a[100];
//    int n;
//    cin >> n;
//    for(int i=0;i<n;i++)
//        cin >> a[i];
//    sort(a,a+n);
//    int sum=0;
//    while(n>1)
//    {
//        sum+=a[0]+a[1];
//        a[0]=a[0]+a[1];
//        a[1]=-1;
//        sort(a,a+n);
//        for(int i=0;i<n-1;i++)
//            a[i]=a[i+1];
//        n--;
//    }
//    cout << sum ;
//    return 0;
//}

//#include<iostream>
//#include<string>
//using namespace std;
//
//int tot,c[10],n,num;
//int map[10][10];
//int vis[100][10];
//
//void Dfs(int cur)
//{
//    if(cur==n)
//    {
//        for(int f=0;f<n;f++)
//            vis[tot][f]=c[f];
//        tot++;
//    }
//
//    else
//    {
//        for(int i=0;i<n;i++)
//            if(map[cur][i]==1)
//            {
//                int ok=1;
//                c[cur]=i;
//                for(int j=0;j<cur;j++)
//                {
//                    if(c[cur]==c[j]||cur-c[cur]==j-c[j]||cur+c[cur]==j+c[j])
//                    {
//                        ok=0;
//                        break;
//                    }
//                }
//                if(ok)
//                    Dfs(cur+1);
//            }
//    }
//}
//
//bool isMutexLine(int a[],int b[])// 判断两行是否互斥
//{
//    for(int i=0;i<n;i++)
//    {
//        if(a[i]==b[i])  //黑白皇后在同一格
//            return true;
//    }
//    return false;
//}
//
//void Search(int x)
//{
//    for(int q=0;q<x;q++)
//    {
//        for(int w=q+1;w<x;w++)
//            if(!isMutexLine(vis[q],vis[w]))
//                num++;
//    }
//    cout << 2*num;
//}
//
//int main()
//{
//    int i,j;
//    cin >> n;
//    for(i=0;i<n;i++)
//        for(j=0;j<n;j++)
//            cin >> map[i][j];
//    memset(c,-1,sizeof(c));
//    memset(vis,-1,sizeof(vis));
//    tot=0;
//    num=0;
//    Dfs(0);
//    Search(tot);
//    return 0;
//}

//#include<iostream>
//using namespace std;
//
////const int maxn = 10000+10;
////const int INF = 0X3f3f3f3f;
//
//int vis[10];
//int a,b,c,d,e,f;
//int ans;
//int k[10];
//
//bool juge(int k[]) {
//    memset(vis,0,sizeof(vis));
//    for(int i=0;i<6;i++) {
//        while(k[i]>0) { //记录每一个1-9每个数使用次数
//            vis[k[i]%10]++;
//            if(vis[k[i]%10]>2) return false;
//            k[i] /= 10;
//        
//        }
//    }
//    for(int i=0;i<10;i++) 
//    {
//        if(vis[i] != 2) return false;
//    }
//    return true;
//}
//
//int main()
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=100;i<1000;i++) //枚举前两个三位数
//    {
//        for(int j=100;j<1000;j++)
//        {
//            if(i*(j%10)<1000 && i*(j/10%10)<1000 && i*(j/100)<1000 && i*j<100000)
//            {
//                int s=0;
//                k[s++]=i;//a
//                k[s++]=j;//b
//                k[s++]=i*(j%10);//c
//                k[s++]=i*(j/10%10);//d
//                k[s++]=i*(j/100);//e
//                k[s++]=i*j;//f
//                if(juge(k))
//                    cout << i*j << endl << "a=" << i << endl << "b=" <<j  << endl;
//            }
//        }
//    }
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int x=0;
//    for(x=40;x<50;x++)
//    {
//        if(x*x-1800+x*10+x==x)
//            cout << x << endl;
//    }
//    return 0;
//}


//#include<iostream>
//#include<string.h>
//using namespace std;
//int vis[10];
//int k[10];
//int a,b,c,d,e,f,s;
//bool juge(int k[])
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=0;i<6;i++)
//    {
//        while(k[i]>0)
//        {
//            vis[k[i]%10]++;
//            if(vis[k[i]%10]>2) 
//                return false;
//            k[i] /= 10;
//        }
//    }
//    for(int i=0;i<10;i++)
//    {
//        if(vis[i]!=2)
//            return false;
//    }
//    return true;
//}
//
//int main()
//{
//    memset(vis,0,sizeof(vis));
//    memset(k,0,sizeof(k));
//  
//    for(int i=100;i<1000;i++)
//        for(int j=100;j<1000;j++)
//        {
//            if(i*(j%10)<1000 && i*(j/10%10)<1000 && i*(j/100)<1000 && i*j <100000)
//            {
//                int s=0;
//                k[s++] = i;
//                k[s++] = j;
//                k[s++] = i*(j%10);
//                k[s++] = i*(j/10%10);
//                k[s++] = i*(j/100);
//                k[s++] = i*j;
//                if(juge(k))
//                    cout << i*j;
//            }
//    
//        }
//}



//#include<iostream>
//#include<cstring>
//
//using namespace std;
//int vis[10];
//int a,b,c,d,e,f;
//int ans;
//int k[10];
//
//bool juge(int k[])
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=0;i<6;i++)
//    {
//        while(k[i]>0)
//        {
//            vis[k[i]%10]++;
//            if(vis[k[i]%10]>2)
//                return false;
//            k[i] /= 10;
//        }
//    }
//    for(int i=0;i<10;i++)
//    {
//        if(vis[i] !=2)
//            return false;
//    }
//    return true;
//}
//
//int main()
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=100;i<1000;i++)
//        for(int j=1000;j<1000;j++)
//        {
//            if(i*(j%10)<1000 && i*(j/10%10) <1000 && i*(j/100) <1000 && i*j<100000)
//            {
//                int s=0;
//                k[s++] = i;
//                k[s++] = j;
//                k[s++] = i*(j%10);
//                k[s++] = i*(j/10%10);
//                k[s++] = i*(j/100);
//                k[s++] = i*j;
//                if(juge(k))
//                    cout << i*j << endl;
//            }
//        }
//    return 0;
//}

//
//#include<iostream>
//using namespace std;
//typedef long long LL;
//char s[20];
//
//LL jieceng(int j) 
//{
//    if(j==0)    return 1;
//    LL cnt=1;
//    for(int i=1;i<=j;i++)
//        cnt*=i;
//    return cnt;
//}
//int main()
//{
//    while(cin >> s)
//    {
//        LL sum =0;
//        int len=strlen(s);
//        for(int j=0;j<len;j++)
//        {
//            LL jiec=jieceng(16-j);
//            int t=s[j]-'a';
//            for(int i=0;i<j;i++)
//                if(s[i]<s[j])
//                    t--;
//            sum+=t*jiec;
//        }
//        cout << sum;
//    }
//    
//    return 0;
//}

//
//#include<iostream>
//using namespace std;
//#include<cstring>
//#define N 17
//
//int main()
//{
//    char tmp[] = "bckfqlajhemgiodnp";
//    long long x = 1;
//    long long sum = 0;
//    int cnt=0;
//    for(int i=1;i<N;i++)
//    {
//        x*=i; //用于求阶乘
//        cnt=0;
//        for(int j=N-1;j<N;j++)
//        {
//            if(tmp[N-i-1]>tmp[j])
//                cnt++;
//        }
//        sum += cnt*x;
//    }
//
//    cout << sum ;
//    return 0;
//}

//#include<iostream>
//using namespace std;
//char s[] = "abcdefghijklmnopq";
//long long fc[18];
//int flag[105];
//int f(int b){
//  int sum=0;
//  for(int i='a';i<b;i++)
//      if(flag[i]==0)sum++;
//  flag[b]=1;
//  return sum;
//}
//int main()
//{
//  char p[]="bckfqlajhemgiodnp";
//  fc[1]=1;
//  for(long long i=2;i<18;i++)  //求阶层
//      fc[i]=fc[i-1]*i;
//  int len=strlen(s);
//  long long sum=0;
//  for(int i=0;i<len-1;i++){   //求每一位对应的值
//      sum+=fc[len-1-i]*(f(p[i]));
//      
//  
//  }
//  cout<<sum<<endl;
//  return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int s[2];
//    s[0]='z';
//    cout << s[0];
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int a,b,c;
//    for(a=0;a<=1000;a++)
//        for(b=0;b<=1000;b++)
//            for(c=0;c<=1000;c++)
//            {
//                if(a*a+b*b+c*c==1000)
//                    
//                    cout << a << " " << b << " " << c << endl;
//            }
//    return 0;
//}

//#include<iostream>  
//using namespace std;  
//int main()  
//{  
//    int a=0,b=0,c=0;  
//    for(a=-99;a<=99;a++)//注意负数也是可以的  
//    {  
//        for(b=-99;b<=99;b++)  
//        {  
//            for(c=-99;c<=99;c++)  
//            {  
//                if(a*a+b*b+c*c==1000)//限制输出条件a小于等于b小于等于c,防止出现重复。  
//                {  
//                    cout<<a<<' '<<b<<' '<<c<<endl;  
//                }  
//            }  
//        }  
//    }  
//    return 0;  
//}


//#include <iostream>  
//#include <cstdio>  
//#include <cstring>  
//#include <string>  
//#include <cmath>  
//#include <vector>  
//#include <algorithm>  
//#include <map>  
//const int N = 1001;  
//using namespace std;  
//int main()   
//{  
//    int mou[20] = {0,31,28,31,30,31,30,31,31,30,31,30,31};  
//    int t = 0;  
//    int year = 2014,m = 11,day = 9;  
//    while(t<=1000)  
//    {  
//        int ps = 0;  
//        if(m == 2 && year%4==0 && year % 400!=0)  
//        {  
//            ps = 1;  
//        }  
//        while(day<=(mou[m]+ps))  
//        {  
//            day++;  
//            t++;  
//            if(t>=1000)  
//                break;  
//        }  
//        if(t>=1000)  
//            break;  
//        day = 1;  
//        m++;  
//        if(m==13)  
//        {  
//            year++;  
//            m = 1;  
//        }  
//        printf("%d %d %d %d\n",year,m,day,t);  
//    }  
//    printf("%d %d %d\n",year,m,day);  
//    return 0;  
//}

//呀 有问题啊 

//#include<iostream>
//using namespace std;
//
//int q(int x)
//{
//    int sum =0;
//    int s[10];
//    memset(s,0,sizeof(s));
//        while(x)
//        {
//                s[x%10]++;
//                x=x/10;
//        }
//        for(int i=0;i<10;i++)
//            if(s[i]!=1)
//                break;
//        for(int i=0;i<10;i++)
//        {
//            sum+=s[i];
//        }
//        return sum;
//}
//int main()
//{
//    int x;
//    for(x=1;x<60000;x++)
//        if(q(x*x)+q(x*x*x)==10)
//            cout << x;    
//    return 0;
//}

//#include<iostream>
//#include<string.h>
//#include<algorithm>
//using namespace std;
//
//const int N = 1001;
//
//bool solve(int a,int b)
//{
//    int ok[10];
//    memset(ok,0,sizeof(ok));
//    while(a)
//    {
//        ok[a%10]++;
//        a/=10;
//    }
//    while(b)
//    {
//        ok[b%10]++;
//        b/=10;
//    }
//    bool flag = true;
//    for(int i=0;i<10;i++)
//    {
//        if(ok[i]!=1)
//        {
//            flag=false;
//            break;
//        }
//    }
//    return flag;
//}
//
//int main()
//{
//    for(int i=1;;i++)
//    {
//        int xx = i*i;
//        int xxx = i*i*i;
//        if(solve(xx,xxx))
//        {
//            cout << i;
//            break;
//        }
//    }
//    
//    return 0;
//
//}

//#include<iostream>
//using namespace std;
//int main()
//{
//    int a,b,c;
//    for(a=0;a<1000;a++)
//        for(b=0;b<1000;b++)
//            for(c=0;c<1000;c++)
//                if(3*a+7*b+c==315 && 4*a+10*b+c==420)
//                {
//                    cout << "a=" << a << endl << "b=" << b << endl << "c=" << c << endl;
//                    cout << a+b+c << endl;
//                    break;
//                }
//
//    return 0;
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//    int a,b,c,d,e,f,g,h;
//    for(a=1;a<=9;a++)
//        for(b=0;b<=9;b++)
//            for(c=0;c<=9;c++)
//                for(d=0;d<=9;d++)
//                    for(e=1;e<=9l;e++)
//                        for(f=0;f<=9;f++)
//                            for(g=0;g<=9;g++)
//                                for(h=0;h<=9;h++)
//                                {
//                                    if((a*1000+b*100+c*10+d)+(e*1000+f*100+g*10+b)==(e*10000+f*1000+c*100+b*10+h))
//                                    {
//                                        cout << a << b << c << d << e << f << g  << h << endl;
//                                        cout << e*1000+f*100+g*10+b << endl;
//                                        cout << endl << endl;
//                                    }
//                                 
//                                }
//    
//    return 0;
//}


//#include<iostream>
//using namespace std;
//int main(void)
//{
//    int i,j,temp,sum;
//    for(i=1;i<=46;i++)
//    {
//        temp = sum = 1225-(i)-(i+1)+(i+1)*i;
//        for(j=3;j<=48;j++)
//        {
//            sum = temp-(j)-(j+1)+(j+1)*j;
//            if(sum==2015)
//                cout << "i=" << i  << "j=" << j << endl;
//        }
//    }
//    
//    return 0;
//}

//#include<iostream>
//using namespace std;
//
//bool judge(int x)
//{
//    int arr[10];
//    memset(arr,0,sizeof(arr));
//
//}
//
//int main(void)
//{
//  
//    int a,b,c,d,e,f,g,h,i,j,k,l,m,n,p,q,r,o;
//    for(a=1;a<=9;a++)
//        for(b=1;b<=9;b++)
//            for(c=1;c<=9;c++)
//                for(d=1;d<=9;d++)
//                    for(e=1;e<=9;e++)
//                        for(f=1;f<=9;f++)
//                        {
//                           g = (a*100+b*10+c)*f/100;
//                           h = (a*100+b*10+c)*f/10%10;
//                           i = (a*100+b*10+c)*f%10;
//                           j = (a*100+b*10+c)*e/100;
//                           k = (a*100+b*10+c)*e/10%10;
//                           l = (a*100+b*10+c)*e%10;
//                           m = (a*100+b*10+c)*d/100;
//                           n = (a*100+b*10+c)*d/10%10;
//                           o = (a*100+b*10+c)*d%10;
//
//                        }
//    
//    return 0;
//}


//#include<iostream>
//#include<cstring>
//
//using namespace std;
//int vis[10];
//int a,b,c,d,e,f;
//int ans;
//int k[10];
//
//bool juge(int k[])
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=0;i<6;i++)
//    {
//        while(k[i]>0)
//        {
//            vis[k[i]%10]++;
//            if(vis[k[i]%10]>2)
//                return false;
//            k[i] /= 10;
//        }
//    }
//    for(int i=0;i<10;i++)
//    {
//        if(vis[i] !=2)
//            return false;
//    }
//    return true;
//}
//
//int main()
//{
//    memset(vis,0,sizeof(vis));
//    for(int i=100;i<1000;i++)
//        for(int j=100;j<1000;j++)
//        {
//            if(i*(j%10)<1000 && i*(j/10%10) <1000 && i*(j/100) <1000 && i*j<100000)
//            {
//                int s=0;
//                k[s++] = i;
//                k[s++] = j;
//                k[s++] = i*(j%10);
//                k[s++] = i*(j/10%10);
//                k[s++] = i*(j/100);
//                k[s++] = i*j;
//                if(juge(k))
//                    cout << i*j << endl;
//            }
//        }
//    return 0;
//}

//#include<iostream>
//#include<string.h>
//using namespace std;
//
//long long  f(int i)
//{
//    if(i==0)
//        return 1;
//    else
//        return i*f(i-1);
//}
//int main(void)
//{
//    char s[20] = "bckfqlajhemgiodnp";
//    long long sum=0;
//    int len = strlen(s),x=0;
//    for(int i=0;i<len;i++)
//    {
//            x=s[i]-'a';
//        for(int j=0;j<i;j++)
//        {
//            if(s[j]<s[i])
//                x--;          
//        }
//        sum+=f(16-i)*x;
//    }
//    cout << sum << endl;
//  
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int main(void)
//{
//    int m,n;
//    cin >> m >> n;
//    int arr[200][200];
//    memset(arr,-1,sizeof(arr));
//    for(int i=0;i<m;i++)
//        for(int j=0;j<n;j++)
//            cin >> arr[i][j];
//
//    int i=-1,j=0;
//    int count = m*n;
//    cout << count << endl;
//    while(count) 
//    {
//        while(arr[++i][j]>0 && i<m)
//        {
//            cout << arr[i][j] << " ";
//            arr[i][j]=-1;
//            count--;
//        }
//        i--;
//        while(arr[i][++j]>0 && j<n)
//        {
//            cout << arr[i][j] << " ";
//            arr[i][j]=-1;
//            count--;
//        }
//        j--;
//        while(arr[--i][j]>0 && i>=0)
//        {
//            cout << arr[i][j] << " ";
//            arr[i][j]=-1;
//            count--;
//        }
//        i++;
//        while(arr[i][--j]>0 && j>=0)
//        {
//            cout << arr[i][j] << " ";
//            arr[i][j]=-1;
//            count--;
//        }
//        j++;
//    }
//    return 0;
//}


//#include<iostream>
//using namespace std;
//int main(void)
//{
//    int v1,v2,t,s,l;
//    cin >> v1 >> v2 >> t >> s >> l;
//    int l1=0,l2=0,t1=0,t2=0,time=0;
//    while(l1<l || l2<l)
//    {
//        if(l1-l2>=t) 
//        {
//            t2+=s;
//            l1=t1*v1;
//            l2=t2*v2;
//        }
//        else
//        {
//            t1++;
//            t2++;
//            l1=v1*t1;
//            l2=t2*v2;
//        }
//    }
//    if(l1>=l)
//    {
//        cout << "R" << " " << t1 <<endl; 
//    }
//    else if(l2>=l)
//    {
//        cout << "T" << " " << t2 << endl;
//    }
//    else
//        cout << "D" << " " << t2 << endl;
//    return 0;
//}


/*#include <cstdio>  
#include <cstring>  

void An(int n)  
{  
    int i;  
    if(n == 1)  
        printf("A");  
    for(i = 2; i <= n; i++)  
    {  
        if(i <= 2)  
            An(i-1);  
        printf("%c", 'A' + i - 1);  
        An(i-1);  
    }  
}  

int main()  
{  
    int n;  
    scanf("%d", &n);  
    An(n);  
    return 0;  
} */ 


// 递归的题先推几个  在找出一般规律

//#include<iostream>
//using namespace std;
//
//void fun(int i)
//{
//    if(i==1)
//        cout << 'A';
//    else
//    {
//        fun(i-1);
//        cout << char('A'+i-1);
//        fun(i-1);
//    }
//}
//int main(void)
//{
//    int n;
//    cin >> n;
//    fun(n);
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int n;
//void An(int x)
//{
//    for(int i=1;i<=x;i++)
//    {
//        cout << "sin(" << i;
//        if(i%2!=0 && i!=x)
//            cout << "-";
//        if(i%2==0 && i!=x)
//            cout << "+";
//    }
//    for(int i=0;i<x;i++)
//        cout << ")";
//}
//
//void Sn(int n)
//{
//    int i,d;
//    d=n;
//    for(int i=0;i<n-1;i++)
//        cout << "(" ;
//    for(i=1;i<=n;i++)
//        An(i);
//    cout << "+" << d;
//    if(d!=1)
//        cout << ")";
//    d--;
//}
//
//int main(void)
//{
//    int n;
//    cin >> n;
//    Sn(n);
//    //An(n);
//    return 0;
//}

//#include<iostream>
//using namespace std;
//
//void Hanoi (int n,char src,char mid, char dest)
//    //将src座上的n个盘子 以mid座为中转 移动到dest座
//
//{
//    if(n==1) {
//        cout << src << "->" << dest << endl;
//        return ;
//    }
//    else 
//    {
//        Hanoi(n-1,src,dest,mid);//先将n-1个盘子从src 移动到mid 
//        cout << src << "->" << dest << endl;
//        Hanoi(n-1,mid,src,dest);//最后将n-1个盘子从mid移动到dest
//        return ;
//
//    }
//}
//int main(void)
//{
//    int n;
//    cin >> n;
//    Hanoi(n,'A','B','C');
//    return 0;
//}

//#include<iostream>
//#include<cmath>
//using namespace std;
//int N;
//int queenPos[100];//用来存放算好的皇后位置 最上角的是(0,0)
//void NQueen(int k)//在0至k-1行皇后应景摆好的情况下 摆第k行及其以后的皇后
//{
//    int i;
//    if(k==N)//N个皇后已经摆好
//    {
//        for(i=0;i<N;i++)
//            cout << queenPos[i]+1 << " ";
//        cout << endl;
//        return ;
//    }
//    for(i=0;i<N;i++)//逐尝试第k个皇后的位置 i表示的是列号
//    {
//        int j;
//        for(j=0;j<k;j++)//和已经摆放好的第k个皇后的位置比较 看是否冲突
//        {
//            if(queenPos[j]==i || abs(queenPos[j]-i)==abs(k-j))
//                break;//冲突 测试下一个位置
//        }
//        if(j==k)//当前选的位置i不冲突
//        {
//            queenPos[k]=i;//将第i个皇后放在位置i
//            NQueen(k+1);
//        }
//    }
//}
//int main(void)
//{
//    cin >> N;
//    NQueen(0);//从第0行开始摆皇后
//    return 0;
//}

//void Nqueen(int k)
//{
//    if(k==N)
//    {
//        for(int i=0;i<N;i++)
//            cout << queen[i] + 1;
//        return ;
//    }
//    else
//    {
//        for(int i=0;i<N;i++){
//            int j;
//            for(int j=0;j<k;j++)
//                if("bu fu he ")
//                    break;
//        }
//        if(k==j)
//            queen[k]=i;
//        Nq(k+1);
//    }
//       
//}

//#include<iostream>
//#include<cstdio>
//#include<cstdlib>
//using namespace std;
//double exp() 
//{
//    // 读入一个逆波兰表达式 并计算其值
//    char s[20];
//    cin >> s;
//    switch(s[0])
//    {
//    case '+': return exp()+exp();
//    case '-': return exp()-exp();
//    case '*': return exp()*exp();
//    case '/': return exp()/exp();
//    default:  return atof(s);
//    }
//}
//int main(void)
//{
//    printf("%lf",exp());
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int factor_value();
//int term_value();
//int expression_value();
//int main(void)
//{
//    cout << expression_value() << endl;
//    return 0;
//}
//
//int expression_value()//求一个表达式的值
//{
//    int result = term_value();//求第一项的值
//    bool more = true;
//    while(more) 
//    {
//        char op = cin.peek();//看附一个字符 不去走
//        if(op=='+' || op== '-')
//        {
//            cin.get();//从中取走一个字符
//            int value = term_value();
//            if(op=='+')
//                result += value;
//            else 
//                result-=value;
//        }
//        else 
//            more = false;
//    }
//    return result;
//}
//
//int term_value()//求一个项的值
//{
//   int result = factor_value();//求第一个银子的值
//   while(true)
//   {
//        char op = cin.peek();
//        if(op=='*'|| op=='/')
//        {
//            cin.get();
//            int value = factor_value();
//            if(op=='*')
//                result *= value;
//            else
//                result /=value;
//        }
//        else
//            break;
//   }
//   return result;
//}
//
//int factor_value()//求一个因子的值
//{
//    int result =0;
//    char c = cin.peek();
//    if(c=='(')
//    {
//        cin.get();
//        result = expression_value();
//        cin.get();
//    }
//    else
//    {
//        while(isdigit(c))
//        {
//            result = 10 * result +c -'0';
//            cin.get();
//            c = cin.peek();
//        }
//    }
//    return result;
//}
//
//#include<iostream>
//using namespace std;
//int f(int n)
//{
//    if(n==1)
//        return 1;
//    if(n==2)
//        return 2;
//    else 
//        return f(n-1)+f(n-2);
//}
//int main()
//{
//    int result = f(5);
//    cout << result;
//    return 0;
//}

// 怎么不管用 

//#include<iostream>
//using namespace std;
//int main()
//{
//    int c,q;
//    while(c=getchar() !=EOF)
//    {
//        if(c=='"')
//        {
//            printf("%c",q?"“":"”");
//            q=!q;
//        }
//    }
//}

//最小周期串
//#include<iostream>
//#include<string.h>
//using namespace std;
//int main()
//{
//    char str[100];
//    cin >> str;
//    int len = strlen(str);
//    for(int i=1;i<=len;i++)
//    {
//        int ok = 1;
//        if(len%i==0)
//        {
//            for(int j=i;j<len;j++)
//            {
//                if(str[j]!=str[j%i])
//                {
//                    ok = 0;
//                    break;
//                }
//            }
//            if(ok){
//            cout<<i<< endl; break;}   
//        }
//    }
//
//}

//#include<iostream>
//using namespace std;
//int main(void)
//{
//    int a,b;
//    
//    while(scanf("%d%d",&a,&b)==2)
//    {
//        if(!a && !b)
//            return 0 ;
//        int ans=0,c=0;
//        for(int i=9;i>=0;i--)
//        {
//            c = (a%10+b%10)+c > 9 ? 1 : 0;
//            ans+=c;
//            a/=10,b/=10;
//        }
//        cout << ans << endl;
//    }
//}


//#include<iostream>
//using namespace std;
//int main(void)
//{
//    int a,b,c=0,ans=0;
//    cin >> a>>b;
//    while(a>0 && b>0)
//    {
//        c = (a%10+b%10)+c > 9 ? 1 : 0;
//        ans+=c;
//        a/=10,b/=10;
//    }
//    cout << ans << endl;
//    return 0;
//}

// 公差为d 长度为10 的等差素数列
//#include<iostream>
//using namespace std;
//int issu(int a){//判断是否是素数 
//for(int i=2;i*i<=a;i++){
//if(a%i==0) return 0;
//}
//return 1;
//}
//
//int dfs(int k,int ai,int gc){
//    //k第k个等差数列, ai这个等差数列的值, gc公差 
//if(k>=10){
//return gc;
//}
//if(!issu(ai)){
//return 0;
//}
//else{
//return dfs(k+1,ai+gc,gc);
//}
//
//
//}
//
//int main(void){
//for(int i=0;i<=500;i++){
//for(int ai=0;ai<=1000;ai++){
//if(dfs(0,ai,i)){
//cout<<i<<" ai="<<ai;
//};
//}
//}
//
//return 0;
//}




//#include<iostream>
//using namespace std;
//const int maxn=3000;
//int f[maxn];
//int main(void)
//{
//    int i,j,n;
//    memset(f,0,sizeof(f));
//    int c=0;
//    cin >> n;
//    f[0]=1;
//    for(i=2;i<=n;i++)
//        for(j=0;j<3000;j++)
//        {
//             int s=f[j]*i+c;
//             f[j]=s%10;
//             c=s/10;
//        }
//    for(j=maxn-1;j>=0;j--)
//        if(f[j])
//            break;
//    for(i=j;i>=0;i--)
//        cout << f[i];
//    cout << endl;
//}


//6174问题  也有问题
//#include<iostream>
//#include<stdio.h>
//#include<string.h>
//using namespace std;
//int get_next(int x)
//{
//    int a,b;
//    char s[10];
//    int n=strlen(s);
//    for(int i=0;i<n;i++)
//        for(int j=i+1;j<n;j++)
//        {
//            if(s[i]>s[j])
//            {
//                char t = s[i];
//                s[i] = s[j];
//                s[j]=t;
//            }
//        }
//        sscanf(s,"%d",&b);
//        //字符串反转
//        for(int i=0;i<n/2;i++)
//        {
//            char t = s[i];
//            s[i] = s[n-1-i];
//            s[n-1-i] = t;
//        }
//        sscanf(s,"%d",&a);
//        return a-b;
//}
//int num[2000];
//int main(void)
//{
//    scanf("%d",num[0]);
//    printf("%d",num[0]);
//    int count=1;
//    cout << get_next(1234);
//    for(;;)
//    {
//        // 生成并输出下一个数
//        num[count]=get_next(num[count-1]);
//        cout << num[count];
//        printf(" -> %d",num[count]);
//        //在数组num中寻找新生成的数
//        int found = 0;
//        for(int i=0;i<count;i++)
//        {
//            if(num[i]==num[count])
//            {found = 1;break;}
//
//        }
//        // 如果找到 则退出循环
//        if(found)   break;
//        count++;
//
//    }
//    cout << endl;
//    return 0;
//}

// 蓝桥 数的读法
//#include<iostream>
//using namespace std;
//int main()
//{
//    long long x ;
//    cin >> x;
//
//    return 0;
//}


// 字典

//#include<stdio.h>
//#include<stdlib.h>
//#include<string.h>
//int n;
//char word[2000][10],sorted[2000][10];
////字符比较函数
//int cmp_char(const void* _a,const void* _b)
//{
//    char* a = (char*)_a;
//    char* b = (char*)_b;
//    return *a-*b;
//}
////字符串比较函数
//char cmp_string(const void* _a,const void* _b)
//{
//    char* a = (char*)_a;
//    char* b = (char*)_b;
//    return strcmp(a,b);
//}
//
//int main(void)
//{
//    int n =0 ;
//    for(;;)
//    {
//         
//    }
//    return 0;
//}
//
//

// 数的划分 也有问题

//#include<iostream>
//using namespace std;
//void f(int n,int *a,int k) 
//{
//    if(n==0)
//    {
//        for(int i=0;i<k;i++) {
//            cout << a[i] << " ";
//            cout << endl;
//        }
//        return;
//    }
//    for(int i=n;i>0;i--)
//    {
//        if(k>0 && i>a[i])   continue;
//        a[k]=i;
//        f(n-i,a,k+1);
//    }
//}
//int main()
//{
//    int b[100];
//    f(6,b,0);
//    return 0;
//}

//#include<iostream>
//using namespace std;
//int f(int n,int k) 
//{
//    if(k==0 || k==n)
//        return 1;
//    return f(n-1,k)+f(n-1,k-1);
//}
//int main()
//{
//    cout << f(10,3) << endl;
//    return 0;
//}

//#include<iostream>
//#include<math.h>
//using namespace std;
//int is_prime(int s)
//{
//    for(int i=2;i<s;i++) {
//        if(s%i==0)
//            return 0;
//        else
//            return 1;
//    }
//
//}
//int lcm (int m,int n)
//{
//    if(abs(m-n)==1)
//        return m*n;
//    if(is_prime(m) && is_prime(n))
//        return m*n;
//
//}
//int main()
//{
//    int q,w;
//    cin >> q >> w;
//    cout << lcm(q,w) << endl;
//    
//    return 0;
//}

//// 最小公倍数=两整数的乘积÷最大公约数
//#include<iostream>
//using namespace std;
//int lcm(int a,int b)
//{
//    if(b==0) return a;
//    else return lcm(b,a%b); // 为什么就能求出最大公约数啊
//}
//
//int main()
//{
//    int m,n;
//    cin >> m >> n;
//    int c = lcm(m,n);
//    cout << m*n/c;
//    return 0;
//}

//#include<iostream>
//using namespace std;
//#include<math.h>
//int D[100][100];
//int MaxSum[100][100];
// int n;
//int MS(int x,int y) // 这里是返回一个路径最大的值 并不是存贮的数组啊
//{
//    if(x==n)
//        MaxSum[x][y]=D[x][y];
//    else if(MaxSum[x][y]!=-1)
//        MaxSum[x][y]=D[x][y];
//    else 
//    {
//        int m = MS(x+1,y);
//        int n = MS(x+1,y+1);
//        return max(m,n)+D[x][y];
//    }
//    return MaxSum[x][y];
//}
//
//int main(void)
//{
//   
//    cin >> n;
//    memset(MaxSum,-1,sizeof(MaxSum));
//    for(int i=0;i<n;i++)
//        for(int j=0;j<=i;j++)
//            cin >> D[i][j];
//    cout << MS(0,0) << endl;
//    
//    return 0;
//}


// 最小公倍数=两整数的乘积÷最大公约数
//#include<iostream>
//using namespace std;
//int lcm(int a,int b)
//{
//    if(b==0) return a;
//    else return lcm(b,a%b); // 为什么就能求出最大公约数啊
//}
//
//int main()
//{
//    int m,n;
//    cin >> m >> n;
//    int c = lcm(m,n);
//    cout << c;
//    return 0;
//}


//思路:f(m-1,n)+f(m,n-1),还鞋的在第一个+租鞋的在第一个 
// 妙啊

//#include<iostream>
//using namespace std;
//int func(int m,int n) 
//{
//    if(m<n)
//        return 0;
//    if(n==0)
//        return 1;
//    else if(m>n)
//        return func(m,n-1) + func(m-1,n);
//
//}
//
//int main()
//{
//    int n = func(3,2);
//    cout << n << endl;
//}

//#include<iostream>
//using namespace std;
//#include<math.h>
//#include<iomanip>
//int main()
//{
//    char alpha;
//    double t,d,h;
//    int i;
//
//    for(;;) 
//    {
//        t=d=200;
//        for(i=0;i<2;i++)
//        {
//            if(alpha=='E')
//                return 0;
//            else if(alpha=='T')
//                cin >> t;
//            else if(alpha=='D')
//                cin >> d;
//            else if(alpha=='H')
//                cin >> h;
//        }
//        if(h==200)
//            h=t+0.5555*(6.11*exp(5417.7530*(1/273.16-1/(d+273.16)))-10);
//        else if(t==200)
//            t=h-0.5555*(6.11*exp(5417.7530*(1/273.16-1/(d+273.16)))-10);
//        else if(d==200)
//             d=1/((1/273.16)-((log((((h-t)/0.5555)+10.0)/6.11))/5417.7530))-273.16;
//
//        cout << setprecision(1) << fixed << "T" <<"D" << d << "H" << h << endl;
//    }
//    return 0;
//}

//#include<iostream>
//#include<string>
//#include<algorithm>
//using namespace std;
//int main(void) 
//{
//    int i;
//    int cipher[26],clear[26];
//    memset(cipher,0,sizeof(cipher));
//    memset(clear,0,sizeof(clear));
//    string input;
//    for(i=0;i<input.length();i++)
//    {
//        cipher[input[i]-'A']++;
//    }
//    cin >> input;
//    for(i=0;i<input.length();i++)
//    {
//        clear[input[i]-'A']++;
//    }
//    sort(cipher,cipher+26);
//    sort(clear,clear+26);
//    for(i=0;i<26;i++)
//    {
//        if(cipher[i]!=clear[i])
//        {
//            cout << "NO" << endl;
//
//        }
//    }
//    cout << "YES" << endl;
//    return 0;
//}


#include<iostream>
using namespace std;

const int MAXN = 1010;
int a[MAXN];
int maxLen[MAXN];
int main() 
{
    int N;
    cin >> N;
    for(int i=1;i<=N;i++) 
    {
        cin >> a[i];
        maxLen[i]=1;
    }
    for(int i=2;i<=N;i++) 
    {
        //每次求第i个为终点的最长上升子序列的长度
        for(int j=1;j<i;j++)
        {
            //查看以第j个数为终点的最长上升子序列
            if(a[i]>a[j])
                maxLen[i]=max(maxLen[i],maxLen[j]+1); 
        }
    }
    cout << * max(maxLen+1,maxLen+N+1) << endl;
    return 0;
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页