CF7E.Defining Macros

Most C/C++ programmers know about excellent opportunities that preprocessor #define directives give; but many know as well about the problems that can arise because of their careless use.

In this problem we consider the following model of #define constructions (also called macros). Each macro has its name and value. The generic syntax for declaring a macro is the following:

#define macro_name macro_value

After the macro has been declared, "macro_name" is replaced with "macro_value" each time it is met in the program (only the whole tokens can be replaced; i.e. "macro_name" is replaced only when it is surrounded by spaces or other non-alphabetic symbol). A "macro_value" within our model can only be an arithmetic expression consisting of variables, four arithmetic operations, brackets, and also the names of previously declared macros (in this case replacement is performed sequentially). The process of replacing macros with their values is called substitution.

One of the main problems arising while using macros — the situation when as a result of substitution we get an arithmetic expression with the changed order of calculation because of different priorities of the operations.

Let's consider the following example. Say, we declared such a #define construction:

#define sum x + y

and further in the program the expression "2 * sum" is calculated. After macro substitution is performed we get "2 * x + y", instead of intuitively expected "2 * (x + y)".

Let's call the situation "suspicious", if after the macro substitution the order of calculation changes, falling outside the bounds of some macro. Thus, your task is to find out by the given set of #define definitions and the given expression if this expression is suspicious or not.

Let's speak more formally. We should perform an ordinary macros substitution in the given expression. Moreover, we should perform a "safe" macros substitution in the expression, putting in brackets each macro value; after this, guided by arithmetic rules of brackets expansion, we can omit some of the brackets. If there exist a way to get an expression, absolutely coinciding with the expression that is the result of an ordinary substitution (character-by-character, but ignoring spaces), then this expression and the macros system are called correct, otherwise — suspicious.

Note that we consider the "/" operation as the usual mathematical division, not the integer division like in C/C++. That's why, for example, in the expression "a*(b/c)" we can omit brackets to get the expression "a*b/c".

宏定义

题目背景与前置知识

大多数 C/C++ 程序员都知道预处理器 #define 指令提供的绝佳机会；但许多人也知道由于使用不当而可能出现的问题。

在这个问题中，我们考虑以下 #define 结构模型（也称为宏）。每个宏都有其名称和值。声明宏的通用语法如下：

# define "宏名称" "宏值"

每当程序被编译后，代码中所有的"宏名称"都会被替换为"宏值"。

题面描述

题目将会给你n个宏定义$1 <= n <= 100$，并且给你一段代码。你需要判断这个代码被宏展开后是否是安全或可疑的。安全的定义是在展开后的宏表达式中，所有宏都在计算过程中被当作为一个整体运算。

例如#define sum x+y后，代码2 * sum就被替换成了2 * x + y，显然这个时候运算的优先级就被打乱了。程序将会先运行$2x$而不将$x+y$作为一个整体进行运算。因此这不是一个安全的宏。

感谢Macw提供翻译

The first line contains the only number $n$ ( $0<=n<=100$ ) — the amount of #define constructions in the given program.

Then there follow $n$ lines, each of them contains just one #define construction. Each construction has the following syntax:

#define name expression

where

• name — the macro name,
• expression — the expression with which the given macro will be replaced. An expression is a non-empty string, containing digits,names of variables, names of previously declared macros, round brackets and operational signs +-*/. It is guaranteed that the expression (before and after macros substitution) is a correct arithmetic expression, having no unary operations. The expression contains only non-negative integers, not exceeding $10^{9}$ .

All the names (#define constructions' names and names of their arguments) are strings of case-sensitive Latin characters. It is guaranteed that the name of any variable is different from any #define construction.

Then, the last line contains an expression that you are to check. This expression is non-empty and satisfies the same limitations as the expressions in #define constructions.

The input lines may contain any number of spaces anywhere, providing these spaces do not break the word "define" or the names of constructions and variables. In particular, there can be any number of spaces before and after the "#" symbol.

The length of any line from the input file does not exceed 100 characters.

输入包含$n+2$行，
第一行输入一个整数，表示宏的个数。
接下来的$n$行每一行输入一个字符串，表示一个宏。
最后输入一个字符串，表示需要被宏替换的代码。

Output "OK", if the expression is correct according to the above given criterion, otherwise output "Suspicious".

输出一个字符串，如果输入的表达式被展开后是安全的，则输出OK，否则输出Suspecious。

对于100%的数据，保证$1 <= n <= 100$。
每一个宏的长度和每一个输入代码的长度也均小于等于100。
保证"宏值"只有基本的四则运算括号和变量组成。

请注意，本题的时间限制为3秒，是默认时间限制的三倍。空间限制为256MB，是默认空间限制的两倍。