#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;
}

#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; //~ ^_^
}

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
}

#include <iostream>
#include <algorithm>
using namespace std;
 
void Perm(char * s)
{
	static char* st = s;
	if(!*(s+1))
	{
		cout<<st<<endl;
		return ;
	}
	else
	{
		for(char *t = s; *t; ++t)
		{
			swap(*s, *t);
			Perm(s + 1);
			swap(*s, *t);
		}
	}
}

#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
 
void Perm(char * s)
{
	static char* st = s;
	if(!*(s+1))
	{
		cout<<st<<endl;
		return ;
	}
	else
	{
		set<char> Set;
		for(char *t = s; *t; ++t)
		{
			size_t size = Set.size();
			Set.insert(*t);
			if(size != Set.size())
			{
				swap(*s, *t);
				Perm(s + 1);
				swap(*s, *t);
			}
		}
	}
}

template <class T>
int BSearch(T *a, size_t n, T v)
{
    assert(a != NULL && n > 0); //! a == NULL || n <= 0 就坏了:-(
    size_t l = 0,
           r = n -1,
           m = l + (r - l) / 2; //! 勿用m=(l+r)/2;
    while(l <= r)
    {
        if(a[m] == v) 
            return (int)m;
        else if(a[m] < v)
            l = m + 1;
        else
            r = m - 1;
    }
    return -1;
}

 
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时归并结束
	}
}

#include <iostream>
#include <cassert>
using namespace std;
struct Node
{
	Node(int n = 0):data(n){}
	int data;
	Node* next;
}; 
void reverse(Node * T)
{
	assert(T); //~ 表头非空
	Node* p = T->next, *t;
	if(p)
	{	//~ 将第一个结点，即未来的表尾next域置空
		t = p->next;
		p->next = NULL;
		p = t;
	}
	while(p)
	{	//~ 将余下结点依次插入表头
		t = p->next;
		p->next = T->next;
		T->next = p;
		p = t;
	}
}
 
//~ 测试代码
int main()
{
	Node *head = new Node, *t = head;
	for(int i = 0; i < 10; ++i)
	{
		t->next = new Node(i);
		t = t->next;
	}
	t->next = NULL;
 
	Node * p = head->next;
	reverse(head);
	while(p)
	{
		cout<<p->data<<endl;
		p = p->next;
	}
 
	return 0;
}

template 
class Queue
{
public:
	Queue(int size = 30);
	~Queue();
	void EnQueue(T value);
	T DeQueue();
	T GetFirst();
	bool IsEmpty();
	bool IsFull();
	void ClearQueue();
private:
	T *queue;
	int front;
	int rare;
	int MaxSize;
	int CurLen;
};
 
template 
Queue::Queue(int size = 30)
{
	queue = new T[size];
	front = 0;
	rare = 0;
	CurLen = 0;
	MaxSize =size;
}
 
template 
Queue::~Queue()
{
	delete queue;
}
 
template
void Queue::EnQueue(T value)
{
	queue[rare] = value;
	rare = (rare + 1)%MaxSize;
	CurLen++;
}
 
template
T Queue::DeQueue()
{
	T value;
	if(IsEmpty())
	{
		cout<<"Empty When Dequeue"<
T Queue::GetFirst()
{
	T value;
	if(IsEmpty())
	{
		cout<<"Empty When GetFirst!"<
bool Queue::IsEmpty()
{
	return (front==rare&&CurLen==0)?true:false;
}
 
template
bool Queue::IsFull()
{
	return (front==rare&&CurLen==MaxSize)?true:false;
}
 
template
void Queue::ClearQueue()
{
	front = 0;
	rare = 0;
	CurLen = 0;
}

template <class T>   
 
class Stack   
{   
public:   
	Stack(int stack_size = 30);   
	~Stack();   
	void Push(T value);   
	T Pop();   
	T Top();   
	bool IsEmpty();   
	bool IsFull();   
	void ClearStack();   
private:   
	int top;   
	T* stack;   
	int size;   
};   
template<class T>   
Stack<T>::Stack(int stack_size)   
{   
	size = stack_size;   
	Stack::stack = new T[size];   
	Stack::top = -1;   
}   
 
template<class T>   
Stack<T>::~Stack()   
{   
	delete []stack;   
}   
 
template<class T>   
void Stack<T>::Push(T value)   
{   
	stack[++top] = value;   
}   
 
template<class T>   
T Stack<T>::Pop()   
{   
	return stack[top--];   
}   
 
template<class T>   
T Stack<T>::Top()   
{   
	return Stack[top];   
}   
 
template<class T>   
bool Stack<T>::IsEmpty()   
{   
	return(top==-1?true:false);   
}   
 
template<class T>   
bool Stack<T>::IsFull()   
{   
	return(top==(size-1)?true:false);   
}   
 
template<class T>   
void Stack<T>::ClearStack()   
{   
	top = -1;   
}

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include "Stack.h"
 
using namespace std;
 
class Calculate
{
public:
	Calculate();
	~Calculate();
	int Cal(string express);
private:
	string ParseString(string express);
	vector<string> MidToBehind(string express);
	int Compute(int a,int b,char operater);
	Stack<int> stack_int;
	Stack<char> stack_char;
};

Calculate::Calculate()
{
 
}
 
Calculate::~Calculate()
{
 
}
 
vector<string> Calculate::MidToBehind(string express)
{
	stringstream strstrm(express);
	char temp_char;
	string temp_str;
	vector<string> result_vec;
	while (strstrm>>temp_char)
	{
		if (temp_char!='('&&temp_char!=')'&&temp_char!='+'&&temp_char!='-'&&temp_char!='*'&&temp_char!='/'&&temp_char!='=')
		{
			strstrm.putback(temp_char);
			strstrm>>temp_str;
			result_vec.push_back(temp_str);
		}
		else if(temp_char == '(')
		{
			stack_char.Push(temp_char);
		}
		else if(temp_char == ')')
		{
			if(stack_char.IsEmpty())
			{
				cout<<"stack is empty when push ')'"<<endl;
				stack_char.ClearStack();
			}
			else
			{
				while (temp_char = stack_char.Pop(),temp_char != '(')
				{
					result_vec.push_back(string(1,temp_char));
					if (stack_char.IsEmpty())
					{
						cout<<"stack is empty when pop,not found the '('"<<endl;
						stack_char.ClearStack();
					}
				}
			}
		}
		else if(temp_char == '+'||temp_char == '-'||temp_char == '*'||temp_char == '/')
		{
			switch (temp_char)
			{
				char temp_char_2;
			case '+':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '(')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '-':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '(')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '*':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '('||temp_char_2 == '+'||temp_char_2 == '-')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '/':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '('||temp_char_2 == '+'||temp_char_2 == '-')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			default:
				break;
			}
		}
		else if (temp_char == '=')
		{
			while (!stack_char.IsEmpty())
			{
				result_vec.push_back(string(1,stack_char.Pop()));
			}
		}
		else
			cout<<"wrong express"<<endl;
	}
	return result_vec;
}
 
int Calculate::Compute(int a,int b,char operater)
{
	switch(operater)
	{
	case '+':
		return a + b;
	case '-':
		return a - b;
	case '*':
		return a * b;
	case '/':
		if(b == 0)
		{
			cout<<"divided by 0!wrong!"<<endl;
			return -1;
		}
		else
			return a / b;
	default:
		break;
	}
	cout<<"Not return"<<endl;
	return -1;
}
 
int Calculate::Cal(string express)
{
	string new_exp = ParseString(express);
	string str_temp;
	vector<string> vec_exp = MidToBehind(new_exp);
	for (vector<string>::iterator it = vec_exp.begin();it != vec_exp.end();it++)
	{
		str_temp = *it;
		if (str_temp!="+"&&str_temp!="-"&&str_temp!="*"&&str_temp!="/")
		{
			int int_temp = 0;
			int time = 1;
			for (string::iterator itr = str_temp.begin();itr != str_temp.end();itr++)
			{
				int_temp = int_temp*10 + (*itr - '0');
			}
			stack_int.Push(int_temp);
		} 
		else
		{
			int a,b;
			b = stack_int.Pop();
			a = stack_int.Pop();
			char ch = str_temp[0];
			int c = Compute(a,b,ch);
			stack_int.Push(c);
		}
	}
	return stack_int.Pop();
}
 
string Calculate::ParseString(string express)
{
	string new_exp;
	bool flag = false;
	for (string::iterator it = express.begin();it != express.end();it++)
	{
		if (*it>='0'&&*it<='9')
		{
			if(flag)
				new_exp.push_back(' ');
			flag = false;
			new_exp.push_back(*it);
		}
		else
		{
			flag = true;
			if(it != express.begin())
				new_exp.push_back(' ');
			new_exp.push_back(*it);
		}
	}
	return new_exp;
}

/*
 * 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

#include<iostream>
#include <string>
#include <fstream>
using namespace std;
 
//~ type char To int
inline int ctoi(char ch)
{
	return ch - '0';
}
 
//~ 接受两个string因子，返回string乘积
string multiply(const string &l, const string &r)
{
	/*
	 * 两长度分别为lenl,lenr的数相乘，结果长度最大为lenl+lenr，
	 * 最小为lenl+lenr-1
	 */
	size_t lenl = l.size();
	size_t lenr = r.size();
	unsigned *tmp = new unsigned[lenl + lenr];
	memset(tmp, 0, (lenl+lenr)*sizeof(unsigned));
 
	//~ 交叉相乘
	for(size_t i = 0; i < lenl; ++i)
		for(size_t j = 0; j < lenr; ++j)
		{
			tmp[i + j + 1] += ctoi(l[i]) * ctoi(r[j]);
		}
 
	//~ 处理进位
	for(size_t i = lenl + lenr-1 ; i > 0; --i)
	{
		tmp[i - 1] += tmp[i] / 10;
		tmp[i] = tmp[i] % 10 + '0';
	}
 
	//~ 将结果转化成string，并返回
	if(tmp[0] == 0)
		return string(tmp+1, tmp + lenl + lenr); //~ 长度为lenl+lenr-1
	else
		tmp[0] += '0'; //~ 长度为lenl+lenr
 
	return string(tmp, tmp + lenl + lenr);
}
 
int main()
{
	string l, r;
	while(cin>>l>>r)
	{
		cout<<multiply(l, r)<<endl;
	}
	return 0;
}

string multiply(const string &l, const string &r)
{
	size_t lenl = l.size();
	size_t lenr = r.size();
	string result(lenl+lenr, '\0');
	for(size_t i = 0; i < lenl; ++i)
		for(size_t j = 0; j < lenr; ++j)
		{
			result[i + j + 1] += ctoi(l[i]) * ctoi(r[j]);
		}
	for(size_t i = lenl + lenr-1 ; i > 0; --i)
	{
		result[i - 1] += (unsigned char)result[i] / 10;
		result[i] = (unsigned char)result[i] % 10 + '0';
	}
	if(result[0] == 0)
		result.erase(0, 1);
	else
		result[0] += '0';
 
	return result;
}

//~ 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;
}