include "testlib.h"
#include <iostream>
#include <sstream>
#include <map>

using ld = long double;

int n, k, m;

ld Evaluate(const std::string& str) {
	if (str.empty()) {
		throw std::runtime_error("Cannot evaluate empty expression");
	}
	for (int64_t i = 0; i < str.size(); ++i) {
		if (str[i] == '(') {
			int64_t j = i + 1;
			int64_t balance = 1;
			while (balance) {
				if (j == str.size()) {
					throw std::runtime_error("Bad brackets");
				}
				if (str[j] == '(') {
					++balance;
				} else if (str[j] == ')') {
					--balance;
				}
				++j;
			}
			std::string new_str = str.substr(i + 1, j - i - 2);
			ld result_in_brackets = Evaluate(new_str);
			std::string string_result = std::to_string(result_in_brackets);
			return Evaluate(str.substr(0, i) + string_result + str.substr(j, str.size() - j));
		}
	}
	for (int64_t i = 0; i < str.size(); ++i) {
		if (str[i] == '+') {
			std::string left = str.substr(0, i);
			std::string right = str.substr(i + 1, str.size() - i - 1);
			return Evaluate(left) + Evaluate(right);
		}
	}
	for (int64_t i = static_cast<int64_t>(str.size()) - 1; i >= 0; i--) {
		if (str[i] == '-') {
			if (i != 0) {
				std::string left = str.substr(0, i);
				std::string right = str.substr(i + 1, str.size() - i - 1);
				return Evaluate(left) + Evaluate(right);
			} else {
				std::string right = str.substr(i + 1, str.size() - i - 1);
				return -Evaluate(right);
			}
		}
	}
	for (int64_t i = 0; i < str.size(); ++i) {
		if (str[i] == '*') {
			std::string left = str.substr(0, i);
			std::string right = str.substr(i + 1, str.size() - i - 1);
			return Evaluate(left) * Evaluate(right);
		}
	}
	for (int64_t i = static_cast<int64_t>(str.size()) - 1; i >= 0; i--) {
		if (str[i] == '/') {
			std::string left = str.substr(0, i);
			std::string right = str.substr(i + 1, str.size() - i - 1);
			return Evaluate(left) / Evaluate(right);
		}
	}
	if (str[0] == ' ') {
		return Evaluate(str.substr(1, str.size() - 1));
	}
	if (str.back() == ' ') {
		return Evaluate(str.substr(0, str.size() - 1));
	}
	if (str == "n") {
		return n;
	} else if (str == "k") {
		return k;
	} else if (str == "m") {
		return m;
	}
	std::stringstream ss;
	ss << str;
	ld result;
	ss >> result;
	return result;
}

std::string correct = "(n - k) / 2 * (m - k - (n - k) / 2)";
const ld EPS = 1e-6;



std::map<std::string, int> kek = {{"(n - k) / 2 * (m - k - (n - k) / 2)", 100},
{"(n - k) * (m - k - (n - k) / 2)", 50},
{"(m - k) / 2 * (n - k - (m - k) / 2)", 70},
{"(n * m - (n - k) / 2 * (n - k) / 2 - n * k - m * k) / 2", 50},
{"(n * m - (n - k) / 2 * (n - k) / 2 - n * k - m * k)", 30},
{"(n-k)*(n-k)/4", 20},
{"(m*n-k*n-k*m)/2-(n-k)/4*(n-k)", 40},
{"m-(n-k)/2-k", 30},
{"(n-k)/2*(m-(n-k)/2)", 50},
{"m-k-(n-k)/2*(n-k)/2", 70},
{"(n-k)/2*(m-(n-k)/2+k)", 60},
{"(n-k)*(m-k)/4", 40},
{"(n-k)/2*(m-1)-k", 10},
{"(n-k)*(2*m-n-3*k)/4", 10},
{"(n-k/2)*(m-k-n+k/2)", 20},
{"(m*n-k*n-k*m+k*k-((n-k)*(n-k))/4)/2", 60},
{"(m-n/2)*(n/2-k)", 10},
{"(n-k)/2*(m-(n-k)-k)", 20},
{"(n-k)/2*(m-n-k/2)", 20},
{"(n-k)/2*(m-k-1)", 20},
{"(n-k)*(m-k)/2", 20},
{"(n-k/2)*(m-k-(n-k)/2)", 60},
{"(n-k)/2*(n-k)", 10},
{"((n-k)/2)*((n-k)/2-k)", 10},
{"(n-k)/2+(m-k-(n-k)/2)", 60},
{"((n*m-(n*k+m*k)-(n-k)/2*4*2))/2", 20},
{"(m*n-k*(m+n)-k*k+((n-k)*(n-k))/4)/2", 60},
{"(n-k)/2*(m-n-k)", 20},
{"(n-k)/2*(m-k)/3", 10},
{"(n-k)*(2*m+n-3*k)/4", 10},
{"((n-k)/2)*(m-k*3)", 10},
{"(m*n-k*m-k*n)/2", 10},
{"(m*n-n+k-k*m-k*n)/2", 10},
{"(n-k)/2*m-((n-k)/2-k)", 60},
{"((n - k) / 2) / (m - ((n - k) / 2) - k)", 60},
{"(n*m-(n-k)/2-n*k-m*k)/2", 20},
{"(n-k)*(m-n)/4", 20},
{"(m/2+k)*(n/2-k/2)", 10},
{"n*m-k*(m+n)", 10},
{"(n/2-k/2)*(m/2+k/2)", 10},
{"m-((n-k)/2)-k*((n-k)/2)", 60},
{"(n*m-(n-k)/2*(m-k)/2-n*k-m*k)/2", 20},
{"((n-k)/2)*((n-k)/2*m-k-(n-k)/2*(n-k)/2)", 10},
{"(n-k)*(2*m-n-k)", 10},
{"(n-k)/2*(m/2)", 10},
{"n*m-((k*n+k*m)-k*k)-((n-k)/2*(n-k)/2)/2", 70},
{"m*n-k*(n+m)-(n-k)/2*(n-k)", 50},
{"(n-2)/2*(m-(n-2)/2-k)", 20},
{"((n-k)/2)*(m-((n-k)/2))-k", 30},
{"((n-k)/2)*((m-k)-n/2)", 20},
{"(n*m-k*m-n*k)/2-((n/2)*(n/2))", 20},
{"(n/2-k/2)*(m-m/3-k)", 20},
{"(n-k)*(m-k)/2-(n-k)", 10},
{"(n*m)-(k*m+k*n)/2", 10},
{"((n*m)-(n*k+m*k))*(2/6)", 10},
{"(n * m - n * k - m * k - (n - k) * (n - k)) / 2", 40},
{"(m*n-(k*m-k*n-k*k))/2-((n-k)/2*(n-k)/2)", 50},
{"n * m - (n - k) / 2 * (n - k) / 2 - k * n - k * m / 2", 20},
{"n*m-((n-k)*(n-k)/2-k*m-k*n+k*k)/2", 60},
{"(n - k) / 2 * (m - (n - k)) / 2", 20},
{"(n-k)/2*(m-k-(n-k)/2*(n-k)/2)", 30},
{"(m * n - k * n - m * k + k * k - (m - k) * (m - k) * 2) / 2", 30},
{"(n*m-(n-k)/2*(n-k)/2-n*k)/2-m*k", 50},
{"((n-k)/2+k-m)*((n-k)/2)", 30},
{"n*m-(k*m+k*n-k*k)/2-(n/2-k/2)*(n/2-k/2)", 60},
{"m*n-k*(m+n-k)-(((k*n-k*k)/2)*((k*n-k*k)/2))*2", 60},
{"((n-k)/2)*(m-(((n-2)/2)*m)-k)", 20},
{"(n*m-n*k-(m-k)*k)/2-k*k", 40},
{"n-k/2*m-k-n-k/2", 60},
{"m - (n - k) / 2 * (n - k) / 2", 10},
{"(n-k)/2*(m-(k+(n-k)*2))", 60},
{"(n - k) / 2 * (m - ((n - k) / 2 + 2))", 20},
{"m*n-m*k--n*k+k*k-(n-k)*(n-k)/4-(n-k)/2*(m-(n-k)/2-k)", 60},
{"((n * m) - (((n / 2 *( n / 2)) * 2) + ((k * m) + (k * n) - (k * k)))) / 2", 20},
{"((n*m-(k*n+k*m))/2-((n-k)*2))/2", 20},
{"(m - (n - k) - 2 * k) / 2 * (n - k) / 2", 40},
{"1/2*(m*k-((m*k+n*k)+1/2*(n-k)*(n-k)))", 10},
{"(n-k)*(2*n-m-k)/4", 10},
{"(n * m - (n - k)) / 2 * ((n - k) / 2 - n * k - m * k) / 2", 10},
{"n*m-k*(n+m)-(n-k)*(n-k)", 10},
{"(n*m-n*k)/2-((n-k)/2)*((n-k)/2+k)", 20},
{"(n * m - (k * m + k * n - k * k - 2 * (n - k) * (n - k))) / 2", 50},
{"m*n-(m*(n+1/2*k)+1/2*n*(1/2*m+k))", 10},
{"(n*m-(n*-k)/2*(n-k)/2-n*k-m*k)/2", 10},
{"n*m - (n*k + m*k - k*k - (n-k)*(n-k)/2)", 50},
{"(n*m)/2 - (k*n)/2 - (k*m)/2 - (k*k)/2 - ((n-k)/2)*((n-k)/2)", 20},
{"(m*n-k*(m+n)-k*k-((n-k)*(n-k))/4)/2", 20},
{"((n-k)/2)*((m-k)*(2/3))", 10},
{"(2*m-3*k-n)*((n-k)/2)", 10},
{"m*n-(((n-k)/2*(n-k)/2)*2-(k*m+k*n))/2", 20},
{"(n * m - (n - k) * (n - k) - k * n - k * m - k * k) / 2", 20},
{"(1 / 2) * (m * n - m * k - n * k) - (1 / 4) * (n + 4) * (n + k)", 20},
{"(n-k)/2*(m-k-n-k/2)", 30},
{"(n * m) - 2 * (n * k / 2) - n * k - m * k + k * k", 10},
{"m * n / 2 - k * ( m + n - k) / 2 - (n - k) * (n + k) / 8", 20},
{"(n * m - k * (m + n) - k * k) / 2 - (n - k / 2) * (n - k / 2)", 60},
{"(n*m-((n-k)*(n-k)/2))/2", 20},
{"m*n-(k*n+k*m)-((m-k)*(n-k)/3)", 10},
{"(n - k) * 2 / (m - k - (n - k) / 2)", 60},
{"(m * n - (m * k + (k * n - k * k))) / 2 - (n * 2 * k) / 2", 20},
{"(n*m-(n-k)/2*(n-k)/-n*k-m*k)/2", 20},
{"(n/2-k/2)*(m/2-k)", 10},
{"n*m/2-m*k/2-(n*k-k*k)/2-(n-k/2)*(n-k/2)", 20},
{"(((m - k) * (n - k) + k * k) - (((n - k) / 2) * ((n - k) / 2) * 2)) / 2", 20},
{"(m * n - k * m - k * n - k * k - ((n - 2) / 2) * ((n - 2) / 2) * 2) / 2", 20},
{"((k - n) * (k + (2 * m) - n)) / 4", 10},
{"(m-(n-k))*((n-k)/2)", 10},
{"( ( ((n-k)/2)*((n-k)/2) )*2 + ( ((n-k)/2) * (m - ((n-k)/2) ) * 2) )", 10},
{"(m - n) * (n - k) - (n - k) * ((n - k) / 2) / 2", 20},
{"(m * n - k * (n - k) + k * k - ((k - n)*(k - n)*2))/2", 20},
{"(m - n / 2 + k / 2) * (n / 2 - k / 2 - k)", 10},
{"n * m - (n - k) * (n - k) - (k * ((n - k) / 2)) - (n * k) - ((n - k) / 2) * (m - ((n - k) / 2 + k)) - (m -((n - k) / 2 + k)) * k", 10},
{"(n*m-n*k-k*m-((n/2-k)*4)*2)/2", 10},
{"((n-k)/(2+1))*(m-k-((n-k)/(2+1)))", 20},
{"m * n - k * (n + m) / 2 - (n - k)* (n - k) / 4", 10},
{"(n - k) * (m - k) - ((n - k) * (n - k) / 4)", 60},
{"(n * m - (n - k) / 2 * (n - k) / 2 - n * k - m * k)", 20},
{"(n*m - (n/2 + k)*m) - ((n - k)/2 * (n-k)/2 + k*(n-k)/2)", 20},
{"(n * m - (n * k - n * m + k * k) - (n - k) * ((n - k) / 2)) / 2", 20},
{"((n-k)/2)*((m-k-(n-k)/2)/2)", 60},
{"(n*k-((k*m)+(n-k)*k)+(((n-k)/2*(n-k)/2)*2))/2", 10},
{"m*n-k*n-(k*m+k*k-(n-k)/2*(n-k)/2)/2", 20}};

int Test(const std::string& str) {
	for (int k1 = 1; k1 <= 5; ++k1) {
		for (int n1 = k1 + 2; n1 <= 100; ++n1) {
			for (int m1 = n1 + 1; m1 <= 30; ++m1) {
				k = k1;
				n = n1;
				m = m1;
				std::vector<std::string> expressions;
				for (auto& now : kek) {
					expressions.push_back(now.first);
				}
				bool nice = false;
				for (auto& now : expressions) {
					try {

						ld f1 = Evaluate(now);
						nice = true;
						ld f2 = Evaluate(str);
						if (abs(f1 - f2) >= EPS) {
							kek.erase(now);
						}
					} catch (...) {
						if (!nice) {
							return 0;
						}
						kek.erase(now);
					}
				}
			}
		}
	}
	int result = 0;
	for (auto& now : kek) {
		if (now.second > result) {
			result = now.second;
		}
	}
	return result;
}

int main(int argc, char** argv) {
	setName("check");
	registerTestlibCmd(argc, argv);
	std::string str = ouf.readLine();
	if (str.size() > 1000) {
	    quitf(_pe, "too long");
	}
	int result = Test(str);
	if (result == 100) {
		quitf(_ok, "nice");
	}
	if (result == 0) {
		quitf(_wa, "bad");
	}
	quitp(_pc(result - 16));
}