int
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
qsort_recur(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        qsort_recur(a, m);
        qsort_recur(a + m + 1, n - m - 1);
    }
    else
    {
        qsort_recur(a + m + 1, n - m - 1);
        qsort_recur(a, m);
    }
}

void
qsort_iter(int *a, int n) //~ qsort of 'iterative version
{
    if(n <= 1)
        return ;
    stack<int> ranges; //~ stack of ranges to be sorted
    int l = 0;
    int r = n;
    ranges.push(l); //~ initial range
    ranges.push(r);
    while(!ranges.empty())
    {
        int tr = r = ranges.top(); ranges.pop();
        int tl = l = ranges.top(); ranges.pop();
        if(r - l <= 1) //~ range sorted
            continue;
        //~ partition begins
        int pivot = a[tl];
        while(tr > tl)
        {
            while(tr > tl && a[--tr] > pivot);
            a[tl] = a[tr];
            while(tr > tl && a[++tl] < pivot);
            a[tr] = a[tl];
        }
        a[tl] = pivot;
        //~ partition ends
 
        //~ ranges pushed, with order counting for little
        ranges.push(l); ranges.push(tl);
        ranges.push(tl+1); ranges.push(r);
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>
#include <sys/time.h> //~ gettimeofday()
 
typedef void (*SORTFUN)(int *a, int n);
 
#define ASIZE 24*1024 //~ array size
#define SCOUNT 6 //~ number of sort method
enum {BUBBLE, INSERT, QSORT, HEAP, MERGE, SHELL};
char *fname[SCOUNT] =
    {
        "Bubble", "Insert", "Qsort",
        "Heap", "Merge", "Shell"
    };
 
SORTFUN fpointer[SCOUNT]; //~ pointers to sort functions
 
int array[SCOUNT][ASIZE]; //~ array(s) under sort.
 
long timeused[SCOUNT]; //~ time taken by every sort function
 
/*******************Generate random data*********************/
void
gen_data(void)
{
    srand(time(NULL)); //~ rand seeding
    for(int i = 0; i < ASIZE; ++i) //~ generate random array[0]
    {
        array[0][i] = rand() % ASIZE;
    }
    for(int i = 1; i < SCOUNT; ++i) //~ copy array[0] to the rest
    {
        for(int j = 0; j < ASIZE; ++j)
        {
            array[i][j] = array[i-1][j];
        }
    }
    //NOTE: using TWO loops to maximize caching
}
 
/***********************Time the time**********************/
long
timer(void) //~ Current Time by millisecond
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}
int
main(int AC, char **AV) //~ Both of AC and AV are fascinating ^_^
{
    gen_data();
 
    //NOTE: to disable a function, just comment it out below.
    fpointer[BUBBLE] = bubble_sort;
    fpointer[INSERT] = insert_sort;
    fpointer[QSORT] = quick_sort;
    fpointer[HEAP] = heap_sort;
    fpointer[MERGE] = merge_sort;
    fpointer[SHELL] = shell_sort;
 
    for(int i = 0; i < SCOUNT; ++i)
    {
        long starttime = timer();
        SORTFUN fp = fpointer[i];
        if(fp)
            fp(array[i], ASIZE);
        timeused[i] = timer() - starttime;
    }
 
    //~ Header
    printf("%%Method\t\t%%Time\t\t%%Elements\n");
    printf("-----------------------------------------\n");
    //~ result
    for(int i = 0; i < SCOUNT; ++i)
    {
        printf("%s\t\t%ld\t\t%d\n", fname[i], timeused[i], ASIZE);
    }
    printf("\n");
    return 0;
}

/************************Bubble Sort**************************/
void
bubble_sort(int *a, int n)
{
    for(int i = n - 1; i > 0; --i)
    {
        int issorted = 0; //~ flag, for some optimition
        for(int j = 0; j < i; ++j)
        {
            if(a[j] > a[j+1])
            {
                issorted = 1;
                int tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
        if(!issorted)
            break;
    }
}
 
/************************Insert Sort**************************/
void
insert_sort(int *a, int n)
{
    for(int i = 0; i < n - 1; ++i)
    {
        int j = i + 1;
        int tmp = a[j];
        while(j > 0 && tmp < a[j-1])
        {
            a[j] = a[j-1];
            --j;
        }
        a[j] = tmp;
    }
}
 
/************************Quick Sort**************************/
int
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
quick_sort(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        quick_sort(a, m);
        quick_sort(a + m + 1, n - m - 1);
    }
    else
    {
        quick_sort(a + m + 1, n - m - 1);
        quick_sort(a, m);
    }
}
 
/************************Quik Sort**************************/
void
sift(int *a, int i, int n) //~ sift to rebuild the heap rooted by a[i]
{
    int tmp = a[i];
    while(2*i + 1 < n)
    {
        int j = 2*i + 1;
        if(j + 1 < n && a[j+1] > a[j])
            ++j;
        if(a[j] > tmp)
        {
            a[i] = a[j];
            i = j;
        }
        else
            break;
    }
    a[i] = tmp;
}
void
heap_sort(int *a, int n)
{
    for(int i = (n-2) / 2; i >= 0; --i) //~ build heap
    {
        sift(a, i, n);
    }
    for(int i = 1; i < n; ++i) //~ rebuild the decreasing heap over and over
    {
        int tmp = a[0];
        a[0] = a[n-i];
        a[n-i] = tmp;
        sift(a, 0, n - i);
    }
}
 
/***********************Merge Sort**********************/
void
merge_sort(int *a, int n)
{
    if(n == 1)
        return;
    int *ext = (int*)malloc(sizeof(int) * n / 2);
    merge_sort(a, n / 2);
    merge_sort(a + n / 2, (n + 1) / 2);
 
    memcpy(ext, a, n / 2 * sizeof(int));
    int i = 0, j = n / 2, k = 0;
    while(i < n / 2 && j < n)
    {
        if(a[j] < ext[i])
            a[k++] = a[j++];
        else
            a[k++] = ext[i++];
    }
    while(i < n / 2)
        a[k++] = ext[i++];
    while(j < n)
        a[k++] = a[j++];
    free(ext);
}
 
/***********************Shell Sort**********************/
void
shell_sort(int * a, int n)
{
    int step = n / 2;
    while(step > 0)
    {
        for(int i = step; i < n; ++i)
        {
            int tmp = *(a + i);
            int j = i - step;
            while(j >= 0 && tmp < *(a + j))
            {
                *(a + j + step) = *(a + j);
                j -= step;
            }
            *(a + j + step) = tmp;
        }
        if(step == 2)
            step = 1;
        else
            step = step * 11 / 5; //~ integer is better
    }
}

const int MAXINT = 0xFFFF; //~ 不可达的路径长度上限
struct Node
{
    Node(): w(MAXINT){}
    int src, //~ 最短路径上的上一个顶点
        w; //~ 到该节点的路径长度
};
struct Edge
{
    Edge(){}
    Edge(int f, int t): from(f), to(t){}
    int from,
        to;
};
int
main(int argc, char **argv)
{
    vector<vector<int> > Adj;
    int n, // 顶点数
        m, //~ 边数
        from,
        to,
        w,
        start; //~ 源点
    cin>>n;
    vector<Node> Dist(n);
    for(int i = 0; i < n; ++i)
    {
        Adj.push_back(vector<int>(n, MAXINT));
        Adj[i][i] = 0;
    }
    cin>>m;
    vector<Edge> Edges;
    for(int i = 0; i < m; ++i)
    {
        cin>>from>>to>>w;
        Adj[from][to] = w;
        Edges.push_back(Edge(from, to));
    }
    cin>>start; //~ 从顶点start开始的最短路径
    Dist[start].w = 0; //~
    bool flag = true;
    for( int i = 0; i < n - 1; ++i)
    {
        for(int j = 0; j < Edges.size(); ++j)
        {
            from = Edges[j].from;
            to = Edges[j].to;
            if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
                continue;
            if(Dist[from].w + Adj[from][to] < Dist[to].w)
            {
                Dist[to].w = Dist[from].w + Adj[from][to];
                Dist[to].src = from;
                flag = false;
            }
        }
        if(flag == true)
            break;
        else
            flag = true;
    }
    //~ 检测有无负环路
    for(int j = 0; j < Edges.size(); ++j)
    {
        from = Edges[j].from;
        to = Edges[j].to;
        if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
            continue;
        if(Dist[from].w + Adj[from][to] < Dist[to].w)
        {
            cout<<"Negative Length Cycle Detected!"<<endl;
            return 1;
        }
    }
    //~ 下面代码供测试用
    while(cin>>to)
    {
        int rp = to;
        cout<<Dist[to].w<<" ";
        while(rp != start) //~ 反向输出路径
        {
            cout<<rp<<" <- ";
            if(Dist[to].w == MAXINT) break;
            rp = Dist[rp].src;
        }
        cout<<start<<endl;
    }
    return 0;
}

int foo(int n)
{
	return n;
}
void bar(int n)
{
	return ;
}
struct wrap_int
{
	wrap_int(int _n): n(n) {}
	operator int() { return n; }
	operator int()const { return n; }
	wrap_int operator ++() { return ++n; }
	int n;
};
wrap_int foo(wrap_int n)
{
	return n;
}
int main()
{
	bar(++foo(372)); //~ 此行报错
	bar(++foo(wrap_int(372))); //~ 无错
	return 0;
}

int
main()
{
    vector<int> vec;
    vec.push_back(5);
    vec.push_back(4);
    vec.push_back(3);
    vec.push_back(2);
    vec.push_back(1);
    sort(++vec.begin(), vec.end());
    deque<int> deq;
    deq.push_back(5);
    deq.push_back(4);
    deq.push_back(3);
    deq.push_back(2);
    deq.push_back(1);
    sort(++deq.begin(), deq.end());
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
const int MAXINT = 0xFFFF; //~ 不可达的路径长度上限
class Node
{
public:
    Node(): w(MAXINT), v(false){}
    int src, //~ 最短路径上的上一个顶点
        w; //~ 到该节点的路径长度
    bool v; //~ 标识该节点是否已经加入最短路径集
};
int
main(int argc, char **argv)
{
    vector<vector<int> > Adj;
    int n, // 顶点数
        m, //~ 边数
        from,
        to,
        w,
        min = MAXINT,
        start, //~ 源点
        k; //~ 下一个可以加入的顶点号
    cin>>n;
    vector<Node> Closest(n);
    for(int i = 0; i < n; ++i)
    {
        Adj.push_back(vector<int>(n, MAXINT));
        Adj[i][i] = 0;
    }
    cin>>m;
    for(int i = 0; i < m; ++i)
    {
        cin>>from>>to>>w;
        Adj[from][to] = w;
    }
    cin>>start; //~ 从顶点start开始的最短路径
    Closest[start].w = 0; //~
    k = start;
    for( int i = 0; i < n; ++i)
    {
        min = MAXINT;
        int t; //~ 维护下一个可以加入最短路径集的顶点
        Closest[k].v = true; //~ 加入最短路径集
        for(int j = 0; j < n; ++j) //~ 更新Closest和k
        {
            if(Closest[j].w > Closest[k].w + Adj[k][j])
            {
                Closest[j].w = Closest[k].w + Adj[k][j];
                Closest[j].src = k;
            }
            if(Closest[j].w < min && !Closest[j].v)
            {
                min = Closest[j].w;
                t = j;
            }
        }
        if(min == MAXINT) break; //~ 剩下的顶点不可达
        k = t;
    }
    //~ 下面代码供测试用
    for(int i = 0; i < n; ++i)
    {
        cout<<Closest[i].w<<'\t'<<boolalpha<<Closest[i].v<<endl;
    }
    while(cin>>to)
    {
        int rp = to;
        while(rp != start) //~ 反向输出路径
        {
            cout<<rp<<" <- ";
            rp = Closest[rp].src;
        }
        cout<<start<<endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
struct Edge 
{
	int from, to, w; //~ 不要被假象迷惑，这里是无向图
	Edge(int f, int t, int _w): from(f), to(t), w(_w){}
	/*
	//~ bool operator <(const Edge& e){ return w < e.w; }
	bool operator >(const Edge& e){ return w > e.w; }
	*/
};
//~ 为什么我把operator<重载为成员会出错？
//~ bool operator <(const Edge& e1, const Edge& e2){ return e1.w < e2.w; }
bool operator >(const Edge& e1, const Edge& e2){ return e1.w > e2.w; } 
bool AddEdge(vector<int> & V, const Edge& e);
int main(int argc, char* argv[])
{
	vector<Edge> E;
	int from, to, w;
	int n; //~ 顶点数
	cin>>n;
	vector<int> V(n+1, -1); //~ 顶点并查集
	while (cin>>from>>to>>w) E.push_back(Edge(from, to, w));
 
	make_heap(E.begin(), E.end(), greater<Edge>());
	int count = 0; //~ 已添加边数
	while (E.size())
	{
		Edge e = E[0];
		if(AddEdge(V, e)) //~ 将成功添加的边输出
		{
			count++;
			if(count == n - 1) break; //~ 树已生成完毕
			cout<<e.from<<"->"<<e.to<<": "<<e.w<<endl;
		}
		pop_heap(E.begin(), E.end(),greater<Edge>());
		E.pop_back();
	}
	if (count != n - 1) cout<<"I cannot do what you want."<<endl;
	return 0;
}
 
bool AddEdge(vector<int> & V, const Edge& e)
{
	int i = e.from;
	for (; V[i] > 0;) i = V[i]; //~ 寻找根节点
	int j = e.to;
	for (; V[j] > 0;) j = V[j]; //~ 寻找根节点
	if (i == j)	return false; //~ i,j两节点已经联通
	if (V[i] > V[j]) //~ 将小集合合并至大集合上
	{
		V[i] = j;
		V[j] += V[i];
	}
	else
	{
		V[j] = i;
		V[i] += V[j];
	}
	return true; //~ ^_^
}

int (a);

int (a) = 0;

int a = 0;

int G = 0xFF;
class Mary
{
public:
    Mary()
    {
        Mary(G);
    }
    Mary(int n){ /*Constructing... */}
};
int
main(int argc, char **argv)
{
    Mary M;
    return 0;
}

 
const int N = 32;
char str[N];
int HashSet[113] = {0};
void RandStr(char* str, const int n)
{
	int i = 0;
	for( ; i < n - 1; ++i)
	{
		str[i] = 'a' + rand() % 26;
	}
	str[i] = '\0';
}
 
int main()
{
	srand(time(NULL));
	const int count = 200;
	for(int i = 0; i < count; ++i)
	{
		RandStr(str, N);
		HashSet[SDBMHash(str)%113]++;
	}
	FILE* out = fopen("./result.txt", "w");
	//~ FILE* out = stdout;
	for(int i = 0; i < 113; ++i)
	{
		fprintf(out, "%d\n", HashSet[i]);
	}
	return 0;
}

typedef int Type; //~ 节点数据类型
typedef struct Node
{
	Type data;
	int bf;
	Node *left, *right;
	Node(){ bf = 0; left = right = 0; }
} AVLNode, *AVLTree; //~ 平衡树及其节点
 
void RRotate(AVLTree & T) //~ 右旋处理,T的左孩子成为新子树根
{
	AVLNode * tmp = T->left;
	T->left = tmp->right;
	tmp->right = T;
	T = tmp;
}
 
void LLotate(AVLTree & T) //~ 左旋处理,T的右孩子成为新子树根
{
	AVLNode * tmp = T->right;
	T->right = tmp->left;
	tmp->left = T;
	T = tmp;
}
 
void LBalance(AVLTree & T) //~ 左平衡处理
{
	AVLNode * l = T->left;
	switch(l->bf)
	{
		case 1: //~ LL,单右旋转
			RRotate(T);
			T->bf = l->bf = 0; //~ 更新平衡因子
			return ;
		case -1: //~ LR双旋转
			AVLNode * lr = l->right;
			switch(lr->bf) //~ 更新平衡因子
			{
				case 1:
					l->bf = 0;
					T->bf = -1;
					break;
				case -1:
					T->bf = 0;
					l->bf = 1;
					break;
			}// switch
			lr->bf = 0;
			LLotate(l);
			RRotate(T);
	}// switch
}
 
void RBalance(AVLTree & T) //~ 右平衡处理
{
	AVLNode * r = T->right;
	switch(r->bf)
	{
		case -1: //~ RR,单左旋转
			LLotate(T);
			T->bf = r->bf = 0;
			return ;
		case 1: //~ RL双旋转
			AVLNode * rl = r->left;
			switch(rl->bf)//~ 更新平衡因子
			{
				case 1:
					r->bf = -1;
					T->bf = 0;
					break;
				case -1:
					T->bf = 1;
					r->bf = 0;
					break;
			}// switch
			rl->bf = 0;
			RRotate(r);
			LLotate(T);
	}// switch
}
bool Insert(AVLTree & T, Type & data) //~ 通过插入操作构建AVL树
{
	bool taller = true; //~ 标识此次插入操作是否使该树长高
	if(!T) //~ 该子树为空树，长高
	{
		T = new AVLNode;
		T->data = data;
		return taller;
	} // if
	if(data == T->data) return false; //~ 该数据已存在，不重复插入
	if(data < T->data) //~ 需要将该数据插入左子树
	{
		if(!Insert(T->left, data)) return false; //~ 左子树未长高
		switch(T->bf) //~ 左子树长高，判断是否需要调整
		{
			case 1: //~ 失衡，许进行左平衡调整
				LBalance(T);
				return false;
			case 0: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 1;
				return true;
			case -1: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 0;
				return false;
		} // switch
	} // if
	else
	{
		if(!Insert(T->left, data)) return false;
		switch(T->bf)
		{
			case 1: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 0;
				return false;
			case 0: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = -1;
				return true;
			case -1: //~ 失衡，许进行右平衡调整
				RBalance(T);
				return false;
		} // switch
	} // if
}

template <class T>
class Heap
{
    public:
        //~ 构造容量n的堆
        Heap(size_t n = 64);
        //~ 以数组构造
        Heap(const T* beg, const T* end);
        ~Heap(){delete [] pHeap;}
        //~ 添加元素
        void push(const T& item);
        //~ 返回并删除堆顶元素
        T pop();
        //~ 返回堆顶元素的引用
        T& top()const;//! 不允许修改！
        size_t size() const;//~ 当前元素个数
        size_t capacity() const;//~ 当前容量
    private:
        void resize();//~ 重新调整堆容量
        void adjust(int i);//~ 调整以i为根的子树为最小堆
        T * pHeap;
        size_t _size;
        size_t _capacity;
};
 
template <class T>
Heap<T>::Heap(size_t n): pHeap(new T[n])
{
    _size = 0;
    _capacity = n;
}
template <class T>
Heap<T>::Heap(const T* beg,const T* end)
{
    _capacity = _size = end - beg;
    pHeap = new T[_size];
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = *beg++;
    }
    int i = _size - 1;
    //~ 调用adjust(int)构造最小堆
    for( ; i >= 0; --i)
        adjust(i);
}
template <class T>
void Heap<T>::push(const T& item)
{
    //~ 容量不足时重新分配空间
    if(_size == _capacity)
        resize();
    _size++;
    int i = _size - 1;
    //~ 通过上溯寻找合适的插入位置
    while(i && pHeap[(i-1)/2] > item)
    {
        pHeap[i] = pHeap[(i-1)/2];
        i = (i-1) / 2;
    }
    pHeap[i] = item;
}
template <class T>
T Heap<T>::pop()
{
    //~ assert(_size);
    if(_size <= 0)exit(1);
    T rt = pHeap[0];
    //~ 先将堆尾元素置顶，然后重建
    pHeap[0] = pHeap[--_size];
    if(_size)
        adjust(0);
    return rt;
}
template <class T>
T& Heap<T>::top()const
{
    // assert(_size);
    if(_size <= 0)exit(1);
    return pHeap[0];
}
template <class T>
size_t Heap<T>::size()const
{
    return _size;
}
template <class T>
size_t Heap<T>::capacity()const
{
    return _capacity;
}
template <class T>
void Heap<T>::resize()
{
    T * org = pHeap;
    //~ 调整容量
    _capacity = 2*_capacity + 1;
    pHeap = new T[_capacity];
    //~ 复制堆
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = org[i];
    }
    delete [] org;
}
template <class T>
void Heap<T>::adjust(int i)
{
    //~ 重建以i为根的最小堆，假定其左右子树已是最小堆
    size_t minpos;
    while(2 * i + 1 < _size)
    {
        minpos = i;
        if(2 * i + 2 < _size && pHeap[2*i+2] < pHeap[i])
            minpos = 2 * i + 2;
        if(pHeap[2*i+1] < pHeap[minpos])
            minpos = 2 * i + 1;
        if(minpos == i)
            break;
        swap(pHeap[i], pHeap[minpos]);
        i = minpos;
    }
}

 
template <class T>
void Swap(T& l, T& r) //~ 交换
{
	T t = l; l = r; r = t;
}
 
template <class T>
void Reverse(T* v, size_t size) //~ 反序
{
	size--;
	size_t l = 0;
	while(l < size)
	{
		Swap(v[l++], v[size--]);
	}
}
 
template <class T>
void Exchange(T* v, size_t l, size_t s) //~ 分块交换：前l个与s-l交换
{	//~ 据说叫手摇算法？
	if(l == 0 || s == 0) return ;
	Reverse(v, l);
	Reverse(v+l, s - l);
	Reverse(v, s); 
}
 
template <class T>
void merge(T* v, size_t size)
{
	if(size == 1) //~ 递归终结点1
		return ;
	else if(size == 2) //~ 递归终结点2
	{
		if(v[0] > v[1])
			Swap(v[0], v[1]);
	}
	else
	{
		//~ 分别排序
		merge(v, size/2);
		merge(v+size/2, size-size/2);
		size_t l = 0, r = size/2;
		//~ 原地归并
		while(l < r && r < size) //~ 核心算法
		{
			while(v[l] <= v[r] && l < r) ++l; //~ 找到左面第一个比v[r]大的v[l]
			size_t to_mv = 0; //~ 计数器
			while(v[r] < v[l] && r < size) ++r, ++to_mv; //~ 右侧找到to_mv个比v[l]小的数
			Exchange(v+l, r-l-to_mv, r-l);//~ 将此to_mv个数移到v[l]前面
			l += to_mv; //~ 改变l，继续下一轮循环
		}//~ l >-r 或者 r >= size时归并结束
	}
}

/*
 * pre存放先序序列，
 * in存放中序序列，
 * n为结点个数，
 * 返回二叉树根指针
 */
BTree CreateBT(Type * pre, Type * in, int n)
{
	if(n <= 0)
		return NULL;
	BTree bt = new BTNode;
	Type * p;
	int k;
	bt->data = *pre;
	for(p = in; p < in + n; ++p)
		if(*pre == *p)
			break;
	k = p - in;
	bt->lchild = CreateBT(pre+1, in, k);
	bt->rchild = CreateBT(pre+k+1, p+1, n-k-1);
        return bt;	
}

void R_Rotate (BSTree &p) 
{
    //~ 对以*p为根的二叉排序树作右旋转处理，处理之后p指向新的树根结点，即旋转
    //~ 处理之前的左子树的根结点
    lc=p->lchild ;            //~ lc指向的*p的左子树根结点
    p->lchild=lc->rchild ;    //~ lc的右子树挂接为*p的左子树
    lc->rchild=p ; p=lc ;    //~ p指向新的根结点
}//~ R_Rotate
 
void L_Rotate (BSTree &p)    
{
    //~ 对以*p为根的二叉排序树作左旋处理，处理之后p指向新的树根结点，即旋转
    //~ 处理之前的右子树的根结点
    rc=p->rchild ;            //~ rc指向的*p的右子树根结点
    p->rchild=rc->lchild ;  //~ rc左子树挂接为*p的右子树
    rc->lchild=p ; p=rc ;   //~ p指向新的根结点
}//~ L_Rotate

//~ set实现
#include <iostream>
#include <string>
#include <set>
 
using namespace std;
template<class T>
class my_strcmp
{
    public:
        bool operator ()(const T& lft, const T& rt)
        {
 
            sum1 = lft + rt;
            sum2 = rt + lft;
            return sum1 < sum2;
        }
    private:
        T sum1, sum2;
};
 
int
main()
{
    multiset<string, my_strcmp<string> > strSet;
    string tmp;
    size_t n;
    while(cin>>n && n)
    {
        strSet.clear();
        while(n--)
        {
            cin>>tmp;
            strSet.insert(tmp);
        }
        for(multiset<string, my_strcmp<string> >::iterator itr = strSet.begin(); 
                itr != strSet.end(); ++itr)
        {
            cout<<*itr<<flush;
        }
        cout<<endl;
 
    }
    return 0;
}

//~ sort实现
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
 
using namespace std;
template<class T>
class my_strcmp
{
    public:
        bool operator ()(const T& lft, const T& rt)
        {
            sum1 = lft + rt;
            sum2 = rt + lft;
            return sum1 < sum2;
        }
    private:
        T sum1, sum2;
};
 
int
main()
{
    vector<string> strVec;
    strVec.reserve(1000);
    string tmp;
    size_t n;
    while(cin>>n && n)
    {
        strVec.clear();
        while(n--)
        {
            cin>>tmp;
            strVec.push_back(tmp);
        }
        sort(strVec.begin(), strVec.end(), my_strcmp<string>() );
        for(vector<string>::iterator itr = strVec.begin(); 
                itr != strVec.end(); ++itr)
        {
            cout<<*itr<<flush;
        }
        cout<<endl;
 
    }
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
 
int main()
{
	string cmd;
	string stack[101] = {"http://www.acm.org/"};
	int B = 0, F = B;
	while(cin>>cmd)
	{
		switch(cmd[0])
		{
			case 'Q':
				return 0;
				break;
			case 'V':
				cin>>stack[++B];
				cout<<stack[B]<<endl;
				F = B;
				break;
			case 'B':
				if(--B < 0)
				{
					cout<<"Ignored"<<endl;
					B = 0;
				}
				else
					cout<<stack[B]<<endl;
				break;
			case 'F':
				if(++B > F)
				{
					cout<<"Ignored"<<endl;
					--B;
				}
				else
					cout<<stack[B]<<endl;
				break;
			default:
				break;
		}
	}
	return 0;
}

#include <iostream>
#include <cmath>
using namespace std;
 
int main(int argn, char** str)
{
	int N = atoi(str[1]);
	if(N <= 2)
	{
		cout<<"NONE"<<endl;
		return 0;
	}
	int sum;
	bool bingo = false;
	for(int n = (int)((sqrt((float)8*N+1)-1)/2); n >= 2; --n)
	{
		sum = n*(n+1)/2;
		if((N-sum)%n == 0)
		{
			bingo = true;
			for(int i = 1; i <= n; ++i)
			{
				cout<<i + (N-sum)/n<<' ';
			}
			cout<<endl;
		}
	}
	if(!bingo)
		cout<<"NONE"<<endl;
 
	return 0;
}

#include <iostream>
#include <algorithm>
#include <ctime>
 
using namespace std;
 
class quick_sort
{
public:
	typedef int T;
	explicit quick_sort(T* src, int beg, int end);
private:
	void sub_sort(int beg, int end);
	T* m_src;
};
 
quick_sort::quick_sort(quick_sort::T *src, int beg, int end):m_src(src)
{
	srand(time(0));
	sub_sort(beg, end);
}
void quick_sort::sub_sort(int beg, int end)
{
	int i = beg - 1, j = end;
	if(end <= beg)
		return;
	T piv = m_src[rand()%(end-beg) + beg];
	for( ; ; )
	{
		while(m_src[++i] < piv);
		while(piv < m_src[--j]);
		if ( i >= j)
			break;
		swap(m_src[i], m_src[j]);
	}
	sub_sort(beg, i);
	sub_sort(i+1, end);
}
 
 
int main()
{
	const int n = 20;
	int src[n];
	for(int i = 0; i < n; ++i)
	{
		src[i] = n - i;
	}
	quick_sort(src, 0, n);
	for(int i = 0; i < n; ++i)
	{
		cout<<src[i]<<endl;
	}
	//system("pause");
	return 0;
}

//本题代码由卧龙孔明提供，十分感谢！
#include<stdio.h>
#include<string.h>
#define mod 100000000
int limit;
int base[400], num;
int dp[12][1<<12];
int map[12];
int m, n;
int dfs(int depth, int st)
{
    if(depth == n) return 1;
    if(dp[depth][st]) return dp[depth][st];
    int i;
    int ans = 0;
    for(i=0; i<num; i++)
    {
        if(base[i] & limit) break;
        if((base[i] & base[st]) == 0 && (base[i] | map[depth]) == map[depth])
        {
            ans += dfs(depth + 1, i);
            ans %= mod;
        }
    }
    dp[depth][st] = ans;
 
    return ans;
}
 
void init()
{
    int i, j, f;
    num = 0;
    for(i=0; i<(1<<12); i++)
    {
        f = 1;
        for(j=0; j<12; j++)
        {
            if( ((i&(1<<j))&&1) + ((i&(1<<(j+1)))&&1) == 2)
            {
                f = 0;
            }
 
        }
        if(f)
        {
            base[num] = i;
            num ++;
        }
    }
}
int main(void)
{
    int i, j, t;
    init();
    while(scanf("%d %d", &n, &m) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        limit = 0xFFFFFFFF;
        limit -= ((1<<m)-1);
        for(i=0; i<n; i++)
        {
            map[i] = 0;
            for(j=0; j<m; j++)
            {
                scanf("%d", &t);
                map[i] <<= 1;
                map[i] += t;
            }
        }
        printf("%d\n", dfs(0, 0));
    }
    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <time.h>
using namespace std;
//------------------------------------------
int main()
{
    clock_t start=clock();   //统计时间
 
    ifstream in("abc.txt");
    for(string s; getline(in,s); )
    {     //读取二进制数
        int b[904]={0},t=0;   //三千位的二进制数都为1时最大，转换后约为2.46e+903,所以取数组904足够
        int a[904]={0};     //数组的每一位放置十进制的一位数，从a[0]到a[903]依次为个位、十位、百位...
        a[0]=1;   //数组初值全为零，第一位为2的0次方，等于1，所以a[0]赋值为1
        reverse(s.begin(),s.end());     //倒置字符串s,数组最低位也为二进制数的最低位,方便求和
        for(int k=0; k<s.size(); k++)
        {     //开始从k=0位读取字符s[k](从原数字的最低位开始)
            if(s[k]=='1')
            {         //等于'0'时，2的k次方为0
                for(int i=t; i<k; i++)
                {   //求2的k次方，每次循环乘2，共乘k-t次,t为保留的上次a[i]累计
                    for(int j=0; j<904; j++) //每一位都乘2
                        a[j]=2*a[j];      
                    t=k;
                    for(int j=0; j<904; j++)     //检查从a[0]到a[903]每位是不是都是个位数
                        if(a[j]>=10)
                        {       //超过10就要进位
                            a[j] = a[j]-10;     //j位大于10进1
                            a[j+1] += 1;   //下位即j+1位要加1
                        }
                }
                for(int j=0; j<904; j++)
                {   //b数组为求和数组，初值为0
                    b[j] += a[j];       //将此次k位上的2的k次方数的大小与b求和
                    if(b[j]>=10)
                    {
                        b[j]=b[j]-10;
                        b[j+1]=b[j+1]+1;
                    }//大于10进1，下一位加1
                } 
            }
        }
 
        int w;  
        for(int i=903; i>=0; i--)     //w为统计此3000位二进制数转化为十进制后的位数
            if(b[i]!=0)
            {
                w=i;
                break;
            }   //从最高位开始，遇到非0数结束
            for(int i=w; i>=0; i--)   //输出结果，注意是从高位开始输出
                cout <<b[i];
            cout <<endl <<"十进制位数为： " <<w+1 <<endl <<endl;   //输出转化后的十进制数位数
    }
    cout <<"Time used ：" <<(double)(clock()-start)/CLOCKS_PER_SEC <<endl;   //输出耗用时间,64个3000位的测试时间为12秒
 
    return 0;
}