class Token {
    // // The type of the Token; can be:
    // Token.TYPE_BOOLEAN
    // Token.TYPE_DOUBLE
    // Token.TYPE_STRING
    // Token.TYPE_LIST
    int type;

    // // Constructors
    // NOTE: You call these like: Token token = new Token(3.0);
    Token(boolean value); // create new boolean-type Token with given value
    Token(double value); // create new double-type Token with given value
    Token(String value); // create new String-type Token with given value
    Token(ArrayList<Token> value); // create new List-type Token with given value

    // // Getters
    // NOTE: You call these like: token.getBoolean()
    // NOTE: These will crash your program if Token is not actually the corresponding type
    boolean getBoolean(); // get value of a boolean-type Token
    double getDouble(); // get value of double-type Token
    String getString(); // get value of String-type Token
    ArrayList<Token> getList(); // get value of List-type Token
}

static class HW05_Stack {
    // // Core functions
    int size(); // number of Tokens in the stack
    void push(Token token); // push a Token to the stack
    Token pop(); // pop a Token from the stack

    // // Special push functions
    void pushBoolean(boolean value); // push(new Token(value));
    void pushDouble(double value); // push(new Token(value));
    void pushString(String value); // push(new Token(value));
    void pushList(ArrayList<Token> value); // push(new Token(value));

    // // Special pop functions
    boolean popBoolean(); // return pop().getBoolean()
    double popDouble(); // return pop().getDouble()
    String popString(); // return pop().getString()
    ArrayList<Token> popList(); // return pop().getList()
}

// A Map stores key-value pairs; similar to a Python dictionary 
class Map<String, Token> {
    // Put key-value pair into the map
    void put(String key, Token value);

    // Get value corresponding to key;
    // NOTE: this crashes the program if key not in map
    Token get(String key);

    // Returns whether map contains a key-value pair with key
    boolean containsKey(String key);
}

static void interpretListOfTokens(ArrayList<Token> tokens, HW05_Stack stack, HashMap<String, Token> map);
static void processSingleToken(Token token, HW05_Stack stack, HashMap<String, Token> map);
static ArrayList<Token> tokenizePostScriptProgram(String program);

// Option A
stack.pushDouble(num);

// Option B
stack.push(new Token(num));

// Option C
Token token = new Token(num);
stack.push(token);

// Option A
double num = stack.popDouble();

// Option B
double num = stack.pop().getDouble();

// Option C
Token token = stack.pop();
double num = token.getDouble();

Token token = stack.pop();
if (token.type == Token.TYPE_BOOLEAN) {
    boolean bool = token.getBoolean();
    ...
} else if (token.type == Token.TYPE_DOUBLE) {
    double num = token.getDouble();
    ...
} else if (token.type == Token.TYPE_STRING) {
    String string = token.getString();
    ...
} else if (token.type == Token.TYPE_LIST) {
    ArrayList<Token> list = token.getList();
}

import java.util.*;
class HW05 extends Cow {

	static class Token {
		int type;

		Token(Token token) { // copy constructor
			this.type = token.type;
			_boolean = token._boolean;
			_double = token._double;
			_String = token._String;
			_List = token._List;
		}
		Token(boolean value) { type = Token.TYPE_BOOLEAN; _boolean = value; } 
		Token(double value) { type = Token.TYPE_DOUBLE; _double  = value; }
		Token(String value) { type = Token.TYPE_STRING; _String  = value; }
		Token(ArrayList<Token> value) { type = Token.TYPE_LIST; _List = value; }

		boolean getBoolean() { ASSERT(type == Token.TYPE_BOOLEAN); return _boolean; }
		double getDouble() { ASSERT(type == Token.TYPE_DOUBLE); return _double; }
		String getString() { ASSERT(type == Token.TYPE_STRING); return _String; }
		ArrayList<Token> getList() { ASSERT(type == Token.TYPE_LIST); return _List; }

		// --

		private boolean _boolean;
		private double _double;
		private String _String;
		private ArrayList<Token> _List;

		static final int TYPE_NONE = 0;
		static final int TYPE_BOOLEAN = 1;
		static final int TYPE_DOUBLE = 2;
		static final int TYPE_STRING = 3;
		static final int TYPE_LIST = 4;


		public String toString() {
			if (type == Token.TYPE_BOOLEAN) { return "" + _boolean; }
			if (type == Token.TYPE_DOUBLE ) { return "" + _double;  }
			if (type == Token.TYPE_STRING ) { return "" + _String;  }
			if (type == Token.TYPE_LIST   ) { return "" + _List;  }
			ASSERT(false);
			return "";
		}
	}

	static ArrayList<Token> tokenizePostScriptProgram(String program) {
		ArrayList<Token> result = new ArrayList<>();
		ArrayList<Token> list = null;
		ArrayList<Token> target = result;
		Scanner scanner = new Scanner(program);
		scanner.useLocale(Locale.US);
		while (scanner.hasNext()) {
			if (scanner.hasNextDouble()) {
				target.add(new Token(scanner.nextDouble()));
			} else if (scanner.hasNextBoolean()) {
				target.add(new Token(scanner.nextBoolean()));
			} else {
				String string = scanner.next().trim();
				if (string.equals("{")) {
					list = new ArrayList<Token>();
					target = list;
				} else if (string.equals("}")) {
					target = result;
					target.add(new Token(list));
				} else if (string.length() != 0) {
					target.add(new Token(string));
				}
			}
		}
		scanner.close();
		return result;
	}

	static class HW05_Stack {
		Token pop() { return _stack.pop(); }
		boolean popBoolean() { return _stack.pop().getBoolean(); }
		double popDouble() { return _stack.pop().getDouble(); }
		String popString() { return _stack.pop().getString(); }
		ArrayList<Token> PopList() { return _stack.pop().getList(); }

		void push(Token token) { _stack.push(new Token(token)); }
		void pushBoolean(boolean value) { _stack.push(new Token(value)); }
		void pushDouble(double value) { _stack.push(new Token(value)); }
		void pushString(String value) { _stack.push(new Token(value)); }
		void pushList(ArrayList<Token> value) { _stack.push(new Token(value)); }

		int size() { return _stack.size(); }

		// ---

		private Stack<Token> _stack;

		HW05_Stack() {
			_stack = new Stack<>();
		}

		public String toString() {
			StringBuilder stringBuilder = new StringBuilder();
			ArrayList<Token> tmp = new ArrayList<>();
			for (Token token : _stack) { tmp.add(token); }
			for (int i = tmp.size() - 1; i >= 0; --i) {
				stringBuilder.append(tmp.get(i).toString());
				if (i != 0) stringBuilder.append('\n');
			}
			return stringBuilder.toString();
		}
	}

	static void interpretListOfTokens(ArrayList<Token> tokens, HW05_Stack stack, HashMap<String, Token> map) {
		boolean PRINT_TOKEN = true;
		boolean PRINT_STACK_AND_MAP = true;
		boolean PRINT_BEGIN_AND_END_INTERPRETING = true;


		if (PRINT_BEGIN_AND_END_INTERPRETING) {
			System.out.println("--- BEGIN INTERPRETING " + tokens + " ----------\n");
		}

		for (Token token : tokens) {
			if (PRINT_TOKEN) {
				System.out.println("> " + token + "\n");
			}

			processSingleToken(token, stack, map);

			if (PRINT_STACK_AND_MAP) {
				// NOTE: only prints map if nonempty
				if (stack.size() > 0) PRINT(stack);
				System.out.println("----- \nstack");
				if (map.size() > 0) {
					System.out.print("+ map ");
					PRINT(map);
				}
				System.out.println();
			}
		}

		if (PRINT_BEGIN_AND_END_INTERPRETING) {
			System.out.println("--- END INTERPRETING " + tokens + " ------------\n");
		}
	}

	static void processSingleToken(Token token, HW05_Stack stack, HashMap<String, Token> map) {

		// TODO

	}

	public static void main(String[] arguments) {
		String program = "5.0";
		// String program = "5.0 2.0 sub 3.0 eq";
		// String program = "/pi 3.14 def /tau pi pi add def";
		// String program = "/pythag { dup mul exch dup mul add sqrt } def 3.0 4.0 pythag";

		ArrayList<Token> tokens = tokenizePostScriptProgram(program);
		HW05_Stack stack = new HW05_Stack(); 
		HashMap<String, Token> map = new HashMap<>();
		interpretListOfTokens(tokens, stack, map);
	}

}