/**
 * That Code Snippets was written by flew_kites
 * snippets means several lines of code which could be applied to many programs
 * I listed some snippets, for copying from here and paste them to improve efficiency
 */

/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*/

/**
 * ! XDOJ prefer scanf("%[^\n]", str) to fgets(str, MAXLEN, stdin)
 * 
 * ! Localy fgets() will read '\n' into str
 * ! But XDOJ will not
 * 
*/



/**
 * Get the substring from a certain another
*/
void subString(const char *src, int start, int end, char *result) {
    int length = strlen(src);

    int j = 0;
    for (int i = start; i <= end; i++) {
        result[j++] = src[i];
    }
    result[j] = '\0';
}

/**
 * Sort increasingly
 * a: int array
 * count: count
*/
void sort(int* a, int count){
    for(int i = 0; i < count-1; i++){
        for(int j = 0; j < count-1-i; j++){
            //compare & swap
            if(a[j] > a[j+1]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

/**
 * Sort 2
 * a: int array
 * count: count
*/
void sort2(int* a, int count){
    for(int i = 0; i < count; i++){
        for(int j = i+1; j < count; j++){
            //compare & swap
            if(a[j] > a[i]){
                int temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
    }
}

/**
 * Get the sum of every digits of 'n' into tar
*/
int getSum(int tar[], int n){
    int r = 0;
    for(int i = 0; i < n; i++){
        r += tar[i];
    }
    return r;
}

/**
 * accept a valid number
 * return 1 if it is a prime number
 * or return 0 if not
*/
int isPrime(int n){
    if(n == 1) return 0;
    for(int i = 2; i <= n/2; i++){
        if(n%i == 0){
            return 0;
        }
    }
    return 1;
}

/**
 * parse factors from num
 * store result to tar[]
 * and return the number of factors
*/
int parseFactor(int num, int tar[]){
    int index = 0;
    for(int i = 1; i < num; i++){
        if(num % i == 0){
            tar[index] = i;
            index++;
        }
    }
    return index;
}

/**
 * parse the number from a string
 * return that number
*/
int parseNumber(char* str){
    int a[100];
    int n = 0;
    for(int i = 0; str[i] != '\0'; i++){
        if(str[i] >= '0' && str[i] <= '9'){
            a[n++] = str[i] - '0';
        }
    }

    int num = 0;
    for(int i = 1; i < n; i++){
        num = num * 10 + a[i];
    }

    return num;
}

/**
 * Swap a & b
*/
void swap(int* a, int* b){

    //Do not remove this unless you know what will happen
    if(*a == *b) return;
    
    *a ^= *b;
    *b ^= *a;
    *a ^= *b;
}

/*
题目2：数列分段
问题描述
　　给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中共有多少段？
输入格式
　　输入的第一行包含一个整数n，表示数列中整数的个数。
　　第二行包含n个整数a1, a2, …, an，表示给定的数列，相邻的整数之间用一个空格分隔。
输出格式
　　输出一个整数，表示给定的数列有多个段。
样例输入
8
8 8 8 0 12 12 8 0
样例输出
5
样例说明
　　8 8 8是第一段，0是第二段，12 12是第三段，倒数第二个整数8是第四段，最后一个0是第五段。
评测用例规模与约定
1 ≤ n ≤ 1000，0 ≤ ai ≤ 1000。
*/

#include <stdio.h>

int main(){
    int count, num = 1;
    int temp, now;
    
    scanf("%d", &count);
    
    scanf("%d", &temp);
    for(int i = 1; i<count; i++){
        
        scanf("%d", &now);
        if(temp != now){
            temp = now;
            num++;   
        }
    }

    printf("%d", num);
}

/*
题目3：最小差值
问题描述
　　给定n个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。
输入格式
　　输入第一行包含一个整数n。
　　第二行包含n个正整数，相邻整数之间使用一个空格分隔。
输出格式
　　输出一个整数，表示答案。
样例输入
5
1 5 4 8 20
样例输出
1
样例说明
　　相差最小的两个数是5和4，它们之间的差值是1。
样例输入
5
9 3 6 1 3
样例输出
0
样例说明
　　有两个相同的数3，它们之间的差值是0.
数据规模和约定
对于所有评测用例，2 ≤ n ≤ 1000，每个给定的整数都是不超过10000的正整数。
*/
#include <stdio.h>
#include <math.h>

int sub(int a, int b){
    return abs((a-b));
}

int main(){
    // define
    int count;
    int min = 0;
    int num[1001];

    // input
    scanf("%d", &count);
    for(int i = 0; i < count; i++){
        scanf("%d", &num[i]);
    }

    // init min
    min = sub(num[0], num[1]);

    // iterate
    for(int i = 0; i < count; i++){
        for(int j = i+1; j <= count-1; j++){
            if(min > sub(num[i], num[j])){
                min = sub(num[i], num[j]);
                //                    ^Error
            }
        }
    }

    // output
    printf("%d", min);
}

//AI

/*
题目5：消除类游戏
问题描述
　　消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。
　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。
　　请注意：一个棋子可能在某一行和某一列同时被消除。
输入格式
　　输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。
　　接下来n行，每行m个整数，用空格分隔，分别表示每一个方格中的棋子的颜色。颜色使用1至9编号。
输出格式
　　输出n行，每行m个整数，相邻的整数之间使用一个空格分隔，表示经过一次消除后的棋盘。如果一个方格中的棋子被消除，则对应的方格输出0，否则输出棋子的颜色编号。
样例输入1
4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4
样例输出1
2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4
样例说明
　　棋盘中第4列的1和第4行的2可以被消除，其他的方格中的棋子均保留。
样例输入2
4 5
2 2 3 1 2
3 1 1 1 1
2 3 2 1 3
2 2 3 3 3
样例输出2
2 2 3 0 2
3 0 0 0 0
2 3 2 0 3
2 2 0 0 0
样例说明
　　棋盘中所有的1以及最后一行的3可以被同时消除，其他的方格中的棋子均保留。
评测用例规模与约定
所有的评测用例满足：1 ≤ n, m ≤ 30。
*/
#include <stdio.h>
#include <string.h>

#define MAX 30

int board[MAX][MAX];
int mark[MAX][MAX];

void markRow(int n, int m) {
    for (int i = 0; i < n; i++) {
        int j = 0;
        while (j < m) {
            int k = j;
            while (k < m && board[i][k] == board[i][j]) k++;
            if (k - j >= 3)
                for (int l = j; l < k; l++) mark[i][l] = 1;
            j = k;
        }
    }
}

void markColumn(int n, int m) {
    for (int j = 0; j < m; j++) {
        int i = 0;
        while (i < n) {
            int k = i;
            while (k < n && board[k][j] == board[i][j]) k++;
            if (k - i >= 3)
                for (int l = i; l < k; l++) mark[l][j] = 1;
            i = k;
        }
    }
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            scanf("%d", &board[i][j]);
    memset(mark, 0, sizeof(mark));
    markRow(n, m);
    markColumn(n, m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mark[i][j]) printf("0 ");
            else printf("%d ", board[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int getSum(int num){
    int r = 0;
    while(num > 0){
        r += num % 10;
        num /= 10;
    }
    return r;
}

/**
 * sumA < sumB ? 1 : 0
 * if sumA == sumB return a < b ? 0 : 1
*/
int compare(int a, int b){
    if(getSum(a) < getSum(b)) return 1;
    if(getSum(a) > getSum(b)) return 0;
    return a < b ? 0 : 1;
}

void sort(int* a, int count){
    for(int i = 0; i < count-1; i++){
        for(int j = 0; j < count-1-i; j++){

            //swap
            if(compare(a[j], a[j+1])){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

int main(){
    int user;
    scanf("%d", &user);
    
    int num[1000];
    for(int i = 0; i < user; i++){
        scanf("%d", &num[i]);
    }

    sort(num, user);

    for(int i = 0; i < user; i++){
        printf("%d %d\n", num[i], getSum(num[i]));
    }

    return 0;
}

/*
试题名称	车牌限行
时间限制:	1 秒
内存限制:	256KB

问题描述
受雾霾天气影响，某市决定当雾霾指数超过设定值时对车辆进行限行，假设车牌号全为数字，且长度不超过6位，限行规则如下： 
（1）限行时间段只包括周一至周五，周六周日不限行； 
（2）如果雾霾指数低于200，不限行； 
（3）如果雾霾指数大于等于200且低于400，每天限行两个尾号的汽车，周一限行1和6，周二限行2和7，周三限行3和8，周四限行4和9，周五限行5和0； 
（4）如果雾霾指数大于等于400，每天限行五个尾号的汽车，周一、周三和周五限行1,3,5,7,9，周二和周四限行0,2,4,6,8。 

---
Day 1~5
<200 X
>=200, <400

现在给出星期几、雾霾指数和车牌号，判断该车牌号是否限行。 

输入说明
输入分为三个整数，第一个整数表示星期几（1~7，1表示周一，2表示周二，依次类推，7表示周日），
第二个整数表示雾霾指数（0~600），第三个整数表示车牌号，整数之间用空格分隔。

输出说明
输出为两个部分，第一部分为车牌最后一位数字，第二部分为限行情况，限行输出yes，不限行输出no。

输入样例1 
4 230 80801 
输入样例2 
3 300 67008

输出样例1 
1 no 
输出样例2 
8 yes 
*/

//Contributed from @bssbs
#include<stdio.h>

int main(){
    int low[5][2] = {1,6, 2,7, 3,8, 4,9, 5,0};
    int day, level, car;
    int isReject;
    
    scanf("%d %d %d", &day, &level, &car);
    car = car % 10;
    
    if(day <= 5 && level >= 200){
        if(level <= 400){
            if(car == low[day-1][1] || car == low[day-1][2]) isReject = 1;
            else isReject = 0;
        }
        else if(level >400){
            if(day % 2 == car % 2) isReject = 1;
            else isReject = 0;
        }
    }
    
    if(isReject) printf("%d yes", car);
    else printf("%d no",car);
    
    return 0;
}

/*
题目3 计算球体重量
	问题描述
	已知铁的比重是7.86，金的比重是19.3。写一个程序，分别计算出给定直径的铁球与金球的质量，假定PI=3.1415926。
	
	输入说明
	输入两个整数，分别表示铁球与金球的直径（单位为毫米）
	
	输出说明
	输出两个浮点数，分别表示铁球与金球的质量（单位为克），小数点后保留3位小数，两个浮点数之间用空格分隔
	
	输入样例
	100  100
	输出样例
	4115.486  10105.456
*/
#include <stdio.h>

#define PI 3.1415926
#define IRON 7.86
#define GOLD 19.3

double weight(double d, double density){
	d = d / 10;
	return (d*d*d*PI*density)/6.0;
}

int main(){
	int i, g;

	scanf("%d  %d", &i, &g);
	printf("%.3f  %.3f", weight(i, IRON), weight(g, GOLD));

	return 0;
}

/*
题目2 温度转换
	问题描述
	已知华氏温度到摄氏温度的转换公式为：摄氏温度= (华氏温度- 32)×5/9，写程序将给定的华氏温度转换为摄氏温度输出。
	
	输入说明
	只有一个整数，表示输入的华氏温度。
	
	输出说明
	输出一个表示摄氏温度的实数，小数点后保留2位有效数字，多余部分四舍五入。
	
	输入样例
	50
	
	输出样例
	10.00
*/
#include <stdio.h>

int main(){
	int f;
	double c;

	scanf("%d", &f);
	c = 5.0/9.0 * (f - 32.0);
	printf("%.2f", c);

	return 0;
}

/*
题目11：整数简单运算
问题描述：编写程序，计算用户输入的两个整数的和、差、乘积（*）和商（/）。
输入格式：输入两个整数，整数之间用空格分隔。
输出格式：输出四个整数结果，分别表示和、差、积和商，每输出一个结果换行。
输入样例：
3 4
输出样例：
7
-1
12
0
*/
#include <stdio.h>

int main(){
    int a,b;
    scanf("%d %d", &a, &b);
    
    printf("%d\n", a + b);
    printf("%d\n", a - b);
    printf("%d\n", a * b);
    printf("%d", a / b);
    return 0;
}

/*
1.	A+B+C
问题描述：
通过键盘输入三个整数a，b，c，求3个整数之和。

输入说明：
三整形数据通过键盘输入，输入的数据介于-100000和100000之间，整数之间以空格、跳格或换行分隔。 

输出说明：
输出3个数的和。

输入样例：
-6  0  39

输出样例：
33
*/
#include <stdio.h>

int main(){
    int a, b, c, r;
    scanf("%d %d %d", &a, &b ,&c);
    r = a+b+c;
    printf("%d", r);
    return 0;
}

/*
1.	字符输入输出
问题描述：
通过键盘输入5个大写字母，输出其对应的小写字母，并在末尾加上“！”。

输入说明：
5个大写字母通过键盘输入，字母之间以竖线“|”分隔。

输出说明：
输出5个大写字母对应的小写字母，之间无分隔，并在末尾加上‘！’。

输入样例：
H|E|L|L|O

输出样例：
hello!

*/
#include <stdio.h>

int main(){
    char a,b,c,d,e;
    scanf("%c|%c|%c|%c|%c", &a, &b, &c, &d, &e);
    printf("%c", a+32);
    printf("%c", b+32);
    printf("%c", c+32);
    printf("%c", d+32);
    printf("%c", e+32);
    printf("!");
}

/*
1.	数字字符
问题描述：
通过键盘输入1个整数a（0<=a<=4）,1个数字字符b（’0’<=b<=’5’），求a+b。

输入说明：
整形数据、数字字符通过键盘输入，输入的整形数据介于0和4之间，输入的数字字符介于‘0’和‘5’之间，二个输入数之间用“，”分隔。

输出说明：
分别以整数形式及字符形式输出a+b，输出的二个数之间用“，”分隔。

输入样例：
3 ,5

输出样例：
56，8

*/
#include <stdio.h>

int main(){
    short int a;
    char b;
    scanf("%hd,%c", &a, &b);
    printf("%d,%c",a+b,a+b);
}

/*
1.	实数运算
问题描述：
通过键盘输入长方体的长、宽、高，求长方体的体积V（单精度）。

输入说明：
十进制形式输入长、宽、高，输入数据间用空格分隔。

输出说明：
单精度形式输出长方体体积V，保留小数点后3位，左对齐。

输入样例：
15  8.12  6.66

输出样例：
 811.188

*/
#include <stdio.h>

int main(){
    float l, w, h;

    scanf("%f %f %f", &l, &w, &h);
    printf("%-8.3f", l*w*h);

    return 0;
}

/*
1.	四则运算
问题描述：
输入两个整数和一个四则运算符，根据运算符计算并输出其运算结果（和、差、积、商、余之一）。注意做整除及求余运算时，除数不能为零。

输入说明：
使用scanf()函数输入两个整数和一个运算符，格式见输入样例。

输出说明：
输出使用printf()函数，格式见输出样例。

输入样例：
5%2

输出样例：
     5%2=1

*/
#include <stdio.h>

int main(){
    short int a, b;
    char c;

    scanf("%hd%c%hd", &a, &c, &b);
    switch(c){
        case '%':
        printf("%d%%%d=%d",a,b,a%b);
        break;
        
        case '+':
        printf("%d+%d=%d",a,b,a+b);
        break;

        case '-':
        printf("%d-%d=%d",a,b,a-b);
        break;

        case '/':
        printf("%d/%d=%d",a,b,a/b);
        break;

        case '*':
        printf("%d*%d=%d",a,b,a*b);
        break;
    }
}

/*
1.	数位输出
问题描述：
输入一个5位整数，求出其各数位数值，并按照从高位到低位的顺序输出，如：输入12345，输出为1 2 3 4 5。

输入说明：
输入一个五位正整数。

输出说明：
按数位从高到低依次输出，各数位之间以一个空格相分隔。

输入样例：
96237

输出样例：
    9 6 2 3 7

*/
#include <stdio.h>

int main(){
    char a[5];
    scanf("%c%c%c%c%c", &a[0], &a[1], &a[2], &a[3], &a[4]);
    printf("%c %c %c %c %c", a[0], a[1], a[2], a[3], a[4]);
}

/**
 * 当然有老实一点的做法
#include <stdio.h>

int main(){
    void swaps(char* a, char* b);
    char a[5];
    scanf("%c%c%c%c%c", &a[0], &a[1], &a[2], &a[3], &a[4]);
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 4-i; j++){
            if(a[j] > a[j+1]){
                swaps(&a[j], &a[j+1]);
            }
        }
    }
    printf("%c %c %c %c %c", a[0], a[1], a[2], a[3], a[4]);
}

void swaps(char* a, char* b){
    *a = (*a)^(*b);
    *b = (*a)^(*b);
    *a = (*a)^(*b);
}

*/

/*
题目：阶梯电价计费
类别：流程控制	
时间限制：2S
内存限制：10000Kb
问题描述：	
电价分三个档次，[0,110]度电，每度电0.5元；(110,210]度电，超出110部分每度电0.55元，超过210度电，超出210部分每度电0.70元，给出一个家庭一月用电量，请计算出应缴的电费（四舍五入，保留小数点后两位小数）。
*/
// count is DOUBLE!!
#include <stdio.h>

int main(){
    double money = 0;
    double count;
    scanf("%lf", &count);

    if(1){
        money += (count>=110) ? 55 : 0.5*count;
        if(count > 110){
            money += (count<=210) ? 0.55*(count-110) : 55;
            if(count > 210){
                money  += 0.7*(count-210);
            }
        }
    }

    printf("%.2f", money);
}

/*
输入说明：
输入数据为一个正实数，表示一月用电量
输出说明：
输出应缴电费，保留2位小数。
输入样例：
输入样例1
100
输入样例2
200
输入样例3
329
输出样例：
输出样例1
50.00
输出样例2
104.50
输出样例3
193.30
*/

/*
标题：计算某月天数
类别：流程控制	
时间限制：2S
内存限制：10000Kb
问题描述：
每年的1，3，5，7，8，10，12月有31天，4，6，9，11月有30天，闰年2月29天，其他年份2月28天，给定年份和月份求该月的天数
*/
#include <stdio.h>

int isLeap(int year){
    return (((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? 1 : 0);
}

int main(){
    const int days_isLeap0[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
    const int days_isLeap1[12] = {31,29,31,30,31,30,31,31,30,31,30,31};

    int year, month, days;
    scanf("%d %d", &year, &month);

    if(isLeap(year)){
        days = days_isLeap1[month-1];
    }else{
        days = days_isLeap0[month-1];
    }

    printf("%d", days);
}
/*
输入说明：
输入由两个正整数a和b构成，a表示年份，b表示月份，a和b之间用空格分隔

输出说明：
根据年份和月份计算该月天数并输出

输入样例	
输入样例1
2000 3
输入样例2
2001 2
输出样例	
输出样例1
31
输出样例2
28
*/

/*
假设n是一个由最多9位数字（d9, …, d1）组成的正整数。编写一个程序计算n的每一位数字之和
输入说明:	
输入数据为一个正整数n
输出说明:	
对整数n输出它的各位数字之和后换行
*/
#include <stdio.h>

int main(){
    int n;
    int sum = 0;
    
    scanf("%d", &n);

    for(int i = 0; i < 9; i++){
        sum += n%10;
        n /= 10;
    }

    printf("%d\n", sum);
}
/*
输入样例:	
3704

输出样例:	
14
*/

/*
请写一个程序，给出指定整数范围[a，b]内的所有完数，0 < a < b < 10000。
一个数如果恰好等于除它本身外的所有因子之和，这个数就称为"完数"。
例如6是完数，因为6=1＋2＋3

输入说明	
输入为两个整数a和b，a和b之间用空格分隔

输出说明	
输出[a，b]内的所有完数，每个数字占一行
*/

#include <stdio.h>

int isOK(int num){
    int sum = 0;
    for(int i = 1; i <= 0.5*num; i++){
        sum += (num%i == 0) ? i : 0;
    }
    return (sum == num) ? 1 : 0;
}

int main(){
    int a,b;
    scanf("%d %d", &a, &b);

    for(int i = a; i <= b; i++){
        if(isOK(i)) printf("%d\n", i);
    }
}

/*
最大公约数（GCD）指某几个整数共有因子中最大的一个，最大公约数具有如下性质，
gcd(a,0)=a
gcd(a,1)=1
因此当两个数中有一个为0时，gcd是不为0的那个整数，
当两个整数互质时最大公约数为1。
输入两个整数a和b，求最大公约数

输入说明：
输入为两个非负整数a和b（0<=a,b<10000），a和b之间用空格分隔，

输出说明：
输出其最大公约数
*/
#include <stdio.h>

int min(int a, int b){
    return (a>b) ? a : b;
}

int main(){
    int gcd = 1;
    int a, b;
    scanf("%d %d", &a, &b);

    for(int i = gcd; i <= min(a,b); i++){
        if(a%i == 0 && b%i == 0) gcd = i;
    }

    printf("%d", gcd);
}

/*
角谷定理定义如下：
对于一个大于1的整数n，如果n是偶数，则n = n / 2。如果n是奇数，则n = 3 * n +1，反复操作后，n一定为1。
例如输入22的变化过程： 22 ->11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1，数据变化次数为15。
输入一个大于1的整数，求经过多少次变化可得到自然数1。

输入说明	
输入为一个整数n，1<n<100000。

输出说明	
输出变为1需要的次数
*/
#include <stdio.h>

int fun(int n){
    int r;
    if(n%2){
        r = 3 * n + 1;
    }else{
        r = n / 2;
    }

    return r;
}

int main(){
    int n, count;
    scanf("%d", &n);
    for(count = 0; n != 1; count++){
        n = fun(n);
    }

    printf("%d", count);
}

#include <stdio.h>

double function(int n){
    double last = 1;
    double next = 1;

    for(int i = 2; i <= n; i++){
        next = 1.0/(1.0+last);
        last = next;
    }

    return next;
}

int main(){
    double n;
    scanf("%lf", &n);

    double v;
    v = function(n);

    printf("%f", v);
}

#include <stdio.h>
#define MAXDIG 4

int isT(int num){
    int user = num; //user
    int n; //Digti

    int a[MAXDIG] = {-1, -1, -1, -1};
    for(n = 0; user > 0; n++){
        a[n] = user % 10;
        user = user / 10;
    }

    int sum  = 0;
    for(int i = 0; i < n; i++){
        sum = sum + a[i]*a[i]*a[i];
    }

    int numberT;
    if(sum == num) numberT = 1;
    else numberT = 0;

    return numberT;
}

int fun(int a, int b){
    int left = a > b ? b : a;
    int right = a > b ? a : b;
    int result = 0;

    for(int i = left; i <= right; i++){
        if(isT(i)) result++;
    }

    return result;
}

int main(){
    //TEST printf("%d %d %d\n", isT(1), isT(153), isT(1000));
    int function(int, int);

    int a, b;
    scanf("%d%d", &a, &b);

    printf("%d\n", fun(a, b));
    printf("%d", function(a, b));

    return 0;
}

/**
 * 提交函数片段，在此整理
*/

int function(int a, int b){
    int left = a > b ? b : a;
    int right = a > b ? a : b;
    int result = 0;

    for(int i = left; i <= right; i++){
        int user = i; //user
        int a[4];
        int sum  = 0;
        int n;// Dig
        
        for(int ii = 0; ii < 4; ii++){
            a[ii] = 0;
        }

        for(n = 0; user > 0; n++){
            a[n] = user % 10;
            user = user / 10;
        }

        for(int j = 0; j < 4; j++){
            if(n == 2) sum = sum + a[j]*a[j];
            if(n == 3) sum = sum + a[j]*a[j]*a[j];
            if(n == 4) sum = sum + a[j]*a[j]*a[j]*a[j];
        }

        if(sum == i) result++;
    }

    return result;
}

#include <stdio.h>

int isPrime(int n){
    int flag = n == 1 ? 0 : 1;
    for(int i = 2; i <= n/2; i++){
        if(n%i == 0){
            flag = 0;
            break;
        }
    }

    return flag;
}

int main(){
    int user;
    scanf("%d", &user);

    int a = 2;
    int b = user - 2;
    

    while(b > user/2){
        if(isPrime(a) && isPrime(b)) break;
        a++;
        b--;
    }

    printf("%d %d", a, b);
}

#include <stdio.h>

/**
 * Compare T37
*/
int compare(int a, int b){
    if(a%2 == 0 && b%2 == 1) return 1;
    if(a%2 == 1 && b%2 == 0) return 0;
    return (a > b) ? 1 : 0;
}

/**
 * 排序函数，由大到小排序
 * 用到的compare函数因题而异
*/
void sort(int* a, int count){
    for(int i = 0; i < count-1; i++){
        for(int j = 0; j < count-1-i; j++){

            //compare & swap
            if(compare(a[j], a[j+1])){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

int main(){
    int user;
    scanf("%d", &user);
    
    int u[100];
    for(int i = 0; i < user; i++){
        scanf("%d", &u[i]);
    }

    sort(u, user);

    for(int i = user-1; i >= 0; i--){
        printf("%d ", u[i]);
    }

    return 0;
}

#include <stdio.h>

int getSum(int num){
    int r = 0;
    while(num > 0){
        r += num % 10;
        num /= 10;
    }
    return r;
}

/**
 * parse int Array from a number
 * return the digits of that array
 * 
 * tar= target
 * num= number
*/
int parseArray(int num, int tar[]){
    tar[0] = num;
    int digits = 0;
    for(int i = 0; i <= digits; i++){
        if(tar[i] >= 10){
            tar[i+1] = tar[i]/10;
            tar[i] = tar[i]%10;
            digits++;
        }
    }
}

int isOK(int num[], int count){
    

    int flag = 1;
    for(int i = 0; i <= count/2; i++){
        if(num[i] != num[count-1-i]) flag = 0;
    }
    return flag;
}

int main(){
    int user;
    scanf("%d", &user);
    
    int tar[10];
    int count = parseArray(user, tar);
    int flag = isOK(tar, count);
    
    if(flag) printf("%d", getSum(user));
    else printf("no");
}

#include <stdio.h>

#define MAXROW 100
#define MAXCOL 100

int main() {
    int row, col;
    scanf("%d%d", &row, &col);

    int arr[MAXROW][MAXCOL];
    for (int y = 0; y < row; y++) {
        for (int x = 0; x < col; x++) {
            scanf("%d", &arr[y][x]);
        }
    }

    int isR = 0;

    for (int y = 0; y < row; y++) {
        int minColIndex = 0;

        // 寻找当前行中最小元素所在的列索引
        for (int x = 1; x < col; x++) {
            if (arr[y][x] < arr[y][minColIndex]) {
                minColIndex = x;
            }
        }

        // 判断当前行最小元素是否也是其所在列的最大元素
        int minValue = arr[y][minColIndex];
        int isMaxInCol = 1;
        for (int i = 0; i < row; i++) {
            if (arr[i][minColIndex] > minValue) {
                isMaxInCol = 0;
                break;
            }
        }

        if (isMaxInCol) {
            isR = 1;
            printf("%d %d %d\n", y, minColIndex, minValue);
        }
    }

    if (isR == 0) printf("no\n");

    return 0;
}

#include <stdio.h>

void sort(int* a, int count){
    for(int i = 0; i < count-1; i ++){
        for(int j = 0; j < count-1-i; j++){
            if(a[j]>a[j+1]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

int main(){
    int user;
    scanf("%d", &user);
    
    int a[100];
    for(int i = 0; i < user; i++){
        scanf("%d", &a[i]);
    }

    sort(a, user);

    int d = a[1] - a[0];
    int hasD = 1;
    for(int i = 2; i < user; i++){
        if(d != a[i] - a[i-1]){
            hasD = 0;
        }
    }

    if(hasD) printf("%d", d);
    else printf("no");

    return 0;
}

/*
给出一组PM2.5数据，按以下分级标准统计各级天气的天数，并计算出PM2.5平均值。
PM2.5分级标准为：
一级优（0<=PM2.5<=50）
二级良（51<=PM2.5<=100为）
三级轻度污染（101<=PM2.5<=150）
四级中度污染（151<=PM2.5<=200）
五级重度污染（201<=PM2.5<=300）
六级严重污染（PM2.5>300）


输入说明	
输入分为两行，
第一行是一个整数n表示天数（1<n<=100）；
第二行为n个非负整数Pi（0<=Pi<=1000），表示每天的PM2.5值，整数之间用空格分隔。

输出说明	
输出两行数据，
第一行为PM2.5平均值，结果保留2位小数；
第二行依次输出一级优，二级良，三级轻度污染，四级中度污染，五级重度污染，六级严重污染的天数。
*/

// Using Pointer, a little f**k out
#include <stdio.h>

#define LEVEL_1 50
#define LEVEL_2 100
#define LEVEL_3 150
#define LEVEL_4 200
#define LEVEL_5 300

int l1 = 0;
int l2 = 0;
int l3 = 0;
int l4 = 0;
int l5 = 0;
int l6 = 0;

int makeLevel(int value){
    if(value <= LEVEL_1) l1++;
    else if(value <= LEVEL_2) l2++;
    else if(value <= LEVEL_3) l3++;
    else if(value <= LEVEL_4) l4++;
    else if(value <= LEVEL_5) l5++;
    else l6++;
}

double average(int *a, int count){
    int sum = 0;
    for(int i = 0; i < count; i++){
        sum += *a;
        a++;
    }

    return (double)sum/count;
}

int main(){
    int day[100];
    int days;
    
    scanf("%d", &days);
    
    for(int i = 0; i < days; i++){
        scanf("%d", &day[i]);
        makeLevel(day[i]);
    }

    printf("%.2f\n", (double)average(&day[0], days));
    printf("%d %d %d %d %d %d", l1, l2 ,l3 ,l4, l5 ,l6);
}