#include?
#include?
#include?

using?namespace?std;

typedef?unsigned?int?DWORD;

class?PostOrder
{
public:
	PostOrder（char?*pInput）
	{
		assert（pInput?!=?0）;
		m_pszInput?=?pInput;
		m_dwSize?=?strlen（pInput）;
		assert（m_dwSize>=3）;
		m_pszOutput?=?new?char[m_dwSize];
		assert（m_pszOutput!=0）;
		memset（m_pszOutput0m_dwSize）;
		m_dwOpIdx?=?0;
		m_dwResult?=?0;
	}

	DWORD?GetPriority（char?ch）
	{
		int?prio?=?0;
		switch?（ch）
		{
		case?‘+‘:
		case?‘-‘:
			prio?=?1;
			break;
		case?‘*‘:
		case?‘/‘:
			prio?=?2;
			break;
		case?‘（‘:
		case?‘）‘:
			prio?=?3;
			break;
		default:
			assert（0）;
		}
	
		return?prio;
	}

	DWORD?Process（）
	{
		char?*pStack?=?new?char[m_dwSize];
		int?StackIdx?=?0;
		DWORD?StackBottomPrio?=?0;

		for（DWORD?i?=?0;?i		{
			char?ch?=?m_pszInput[i];

			if?（（‘0‘?<=?ch）&&（‘9‘>=?ch））
			{
				m_pszOutput[m_dwOpIdx]?=?ch;
				m_dwOpIdx++;
			}
			else
			{
				
				switch?（ch）
				{
					case?‘+‘:
					case?‘-‘:
					case?‘*‘:
					case?‘/‘:

						if?（GetPriority（ch）>StackBottomPrio）
						{
							pStack[StackIdx]?=?ch;
							StackIdx++;

							if?（!StackBottomPrio）?StackBottomPrio?=?GetPriority（ch）;
						
						}
						else
						{
							while（StackIdx?>?0）
							{
								if?（‘（‘?==?pStack[--StackIdx]）
								{
									StackIdx++;
									break;
								}
								else
								{									
									m_pszOutput[m_dwOpIdx]?=?pStack[StackIdx];
									m_dwOpIdx++;	
								}
							}

							DWORD?dwTEMP?=?StackIdx;

							if?（!dwTEMP）?StackBottomPrio?=?0;
							else
							{
								dwTEMP--;
								while（（dwTEMP?>?0）?&&?（‘（‘?!=?pStack[dwTEMP-1]））
								{
									dwTEMP--;
								}

								StackBottomPrio?=?GetPriority（pStack[dwTEMP]）;	
							}

							pStack[StackIdx]?=?ch;
							StackIdx++;
							
						}
						break;

					case?‘（‘:
							pStack[StackIdx]?=?ch;
							StackIdx++;

							StackBottomPrio?=?0;
							break;
							
					case?‘）‘:
						while（StackIdx?>?0）
						{
							if?（‘（‘?!=?pStack[--StackIdx]）
							{
								m_pszOutput[m_dwOpIdx]?=?pStack[StackIdx];
								m_dwOpIdx++;
							}
							else
								break;
						};

						break;
					default:
						assert（0）;
				}
			}
	
		}

		while（StackIdx?>?0）
		{
			StackIdx--;
			m_pszOutput[m_dwOpIdx]?=?pStack[StackIdx];
			m_dwOpIdx++;
		}

		m_pszOutput[m_dwOpIdx]?=?0;

		delete?pStack;

		return?0;
	
	}

	void?calculate（）
	{
		DWORD?dwLen?=?strlen（m_pszOutput）;
		DWORD?*pStack?=?new?DWORD[dwLen]?;
		DWORD?StackIdx?=?0;
		for?（DWORD?dwIdx?=?0;?dwIdx?		{