Problem: 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".

Input

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 109. 



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.

Output

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

Examples

Input

1
#define sum x + y
1 * sum


Output

Suspicious


Input

1
#define sum  (x + y)
sum - sum


Output

OK


Input

4
#define sum  x + y
#define mul  a * b
#define div  a / b
#define expr sum + mul * div * mul
expr


Output

OK


Input

3
#define SumSafe   (a+b)
#define DivUnsafe  a/b
#define DenominatorUnsafe  a*b
((SumSafe) + DivUnsafe/DivUnsafe + x/DenominatorUnsafe)


Output

Suspicious

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
namespace std {
template <typename...>
using void_t = void;
}
template <typename T, typename _ = void>
struct is_container : std::false_type {};
template <typename... Ts>
struct is_container_helper {};
template <typename T>
struct is_container<
    T, typename std::conditional<
           false,
           is_container_helper<decltype(std::declval<T>().size()),
                               decltype(std::declval<T>().begin()),
                               decltype(std::declval<T>().end()),
                               decltype(std::declval<T>().cbegin()),
                               decltype(std::declval<T>().cend())>,
           void>::type> : public std::true_type {};
class IO {
  static const int bufSize = 1 << 18;
  char inBuf[bufSize], outBuf[bufSize];
  char *ip1 = inBuf, *ip2 = inBuf;
  int goodReadBit = 1, op1 = -1, op2 = bufSize - 1;
  __inline__ __attribute__((always_inline)) int gc() {
    return ip1 == ip2 && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),
                          ip1 == ip2)
               ? EOF
               : *ip1++;
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) void __RI(T &x) {
    int ch = gc(), neg = 1;
    x = 0;
    for (; !(isdigit(ch) || ch == '-'); ch = gc()) {
    }
    if (ch == EOF) {
      goodReadBit = 0;
      return;
    }
    if (ch == '-') neg = -1, ch = gc();
    for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) void __RC(T &x) {
    int ch;
    while (isspace(ch = gc())) {
    }
    if (ch == EOF) {
      goodReadBit = 0;
      return;
    }
    x = ch;
  }
  __inline__ __attribute__((always_inline)) void __RS(std::string &x) {
    char ch;
    x.clear();
    for (ch = gc(); isspace(ch); ch = gc()) {
    }
    if (ch == EOF) {
      goodReadBit = 0;
      return;
    }
    for (; !isspace(ch) && ch != EOF; ch = gc()) x.push_back(ch);
  }

 public:
  __inline__ __attribute__((always_inline)) IO &R(char &x) {
    return __RC(x), (*this);
  }
  __inline__ __attribute__((always_inline)) IO &R(unsigned char &x) {
    return __RC(x), (*this);
  }
  __inline__ __attribute__((always_inline)) IO &R(std::string &x) {
    return __RS(x), (*this);
  }
  template <typename T1, typename T2>
  __inline__ __attribute__((always_inline)) IO &R(std::pair<T1, T2> &x) {
    return R(x.first), R(x.second), (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &RA(T *a, int n) {
    for (int i = 0; i < n; ++i) R(a[i]);
    return (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &R(T &x, Args &...args) {
    return R(x), R(args...), (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &RA(T *a, int n, Args... args) {
    for (int i = 0; i < n; ++i) RA(a[i], args...);
    return (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline))
  typename std::enable_if<std::is_integral<T>::value, IO>::type &
  R(T &x) {
    return __RI(x), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline))
  typename std::enable_if<is_container<T>::value, IO>::type &
  R(T &x) {
    for (auto &i : x) R(i);
    return (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) typename std::enable_if<
      std::is_void<std::void_t<decltype(std::declval<T>().read())>>::value,
      IO>::type &
  R(T &x) {
    return x.read(), (*this);
  }

 private:
  char space;
  __inline__ __attribute__((always_inline)) void pc(const char &x) {
    if (op1 == op2) flush();
    outBuf[++op1] = x;
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) void __WI(T x) {
    static char buf[64];
    static int len = -1;
    if (x >= 0) {
      do {
        buf[++len] = x % 10 + 48, x /= 10;
      } while (x);
    } else {
      pc('-');
      do {
        buf[++len] = -(x % 10) + 48, x /= 10;
      } while (x);
    }
    while (len >= 0) {
      pc(buf[len]), --len;
    }
  }

 public:
  __inline__ __attribute__((always_inline)) void flush() {
    fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1;
  }
  __inline__ __attribute__((always_inline)) IO &W(const char &x) {
    return pc(x), (*this);
  }
  __inline__ __attribute__((always_inline)) IO &W(const char *x) {
    while (*x != '\0') pc(*(x++));
    return (*this);
  }
  __inline__ __attribute__((always_inline)) IO &W(const std::string &x) {
    return W(x.c_str()), (*this);
  }
  template <typename T1, typename T2>
  __inline__ __attribute__((always_inline)) IO &W(const std::pair<T1, T2> &x) {
    WS(x.first);
    W(x.second);
    return (*this);
  }
  __inline__ __attribute__((always_inline)) IO &WL() {
    return W('\n'), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) IO &WL(const T &x) {
    return W(x), W('\n'), (*this);
  }
  __inline__ __attribute__((always_inline)) IO &WS() {
    return W(space), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) IO &WS(const T &x) {
    return W(x), W(space), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) IO &WA(T *a, int n) {
    for (int i = 0; i < n; i++) WS(a[i]);
    WL();
    return (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &W(const T &x,
                                                  const Args &...args) {
    W(x), W(space), W(args...);
    return (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &WS(const T &x,
                                                   const Args &...args) {
    return W(x), W(space), W(args...), W(space), (*this);
  }
  template <typename... Args>
  __inline__ __attribute__((always_inline)) IO &WL(const Args &...args) {
    return W(args...), W('\n'), (*this);
  }
  template <typename T, typename... Args>
  __inline__ __attribute__((always_inline)) IO &WA(T *a, int n, Args... args) {
    for (int i = 0; i < n; i++) WA(a[i], args...);
    return (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline))
  typename std::enable_if<std::is_integral<T>::value, IO>::type &
  W(const T &x) {
    return __WI(x), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline))
  typename std::enable_if<is_container<T>::value, IO>::type &
  W(const T &x) {
    for (auto &i : x) WS(i);
    WL();
    return (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) typename std::enable_if<
      std::is_void<std::void_t<decltype(std::declval<T>().write())>>::value,
      IO>::type &
  W(const T &x) {
    return x.write(), (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) IO &operator>>(T &x) {
    R(x);
    return (*this);
  }
  template <typename T>
  __inline__ __attribute__((always_inline)) IO &operator<<(const T &x) {
    W(x);
    return (*this);
  }
  IO() { space = ' '; }
  ~IO() { flush(); }
} io;
const std::int32_t INF = 0x3f3f3f3f;
const std::int64_t INFL = 0x3f3f3f3f3f3f3f3f;
using namespace std;
map<char, int> safetyTable = {{'+', 1}, {'-', 2}, {'*', 3}, {'/', 4}};
map<string, int> safetyVal;
struct Expression {
  string value;
  enum Type { EXPR = 1, VARI = 2 } type;
  Expression *lexpr, *rexpr;
  int safety;
  Expression(string value = "", Type type = EXPR, Expression *lexpr = nullptr,
             Expression *rexpr = nullptr, int safety = -1)
      : value(value), type(type), lexpr(lexpr), rexpr(rexpr), safety(safety) {}
  ~Expression() {
    delete lexpr;
    delete rexpr;
  }
};
string str;
string getToken(int pos) {
  if (isalnum(str[pos])) {
    string res;
    for (; pos < str.size() && isalnum(str[pos]); pos++)
      res.push_back(str[pos]);
    return res;
  } else
    return string(1, str[pos]);
}
Expression *ParseExpr(int &);
Expression *ParseTerm(int &);
Expression *ParseItem(int &);
Expression *ParseExpr(int &pos) {
  if (pos == str.size()) return nullptr;
  Expression *expr = ParseTerm(pos);
  while (str[pos] == '+' || str[pos] == '-') {
    int tPos = pos;
    ++pos;
    expr = new Expression(getToken(tPos), Expression::EXPR, expr,
                          ParseTerm(pos), safetyTable[str[tPos]]);
    if (pos == str.size()) break;
  }
  return expr;
}
Expression *ParseTerm(int &pos) {
  if (pos == str.size()) return nullptr;
  Expression *expr = ParseItem(pos);
  while (str[pos] == '*' || str[pos] == '/') {
    int tPos = pos;
    ++pos;
    expr = new Expression(getToken(tPos), Expression::EXPR, expr,
                          ParseItem(pos), safetyTable[str[tPos]]);
    if (pos == str.size()) break;
  }
  return expr;
}
Expression *ParseItem(int &pos) {
  if (pos == str.size()) return nullptr;
  Expression *expr = nullptr;
  if (isalnum(str[pos])) {
    string tok = getToken(pos);
    expr = new Expression(tok, Expression::VARI);
    expr->safety = safetyVal.count(tok) ? safetyVal[tok] : 5;
    pos += tok.size();
    return expr;
  } else {
    pos++;
    expr = ParseExpr(pos);
    expr->safety = expr->safety ? 5 : 0;
    pos++;
  }
  return expr;
}
Expression *ParseExpr() {
  int pos = 0;
  return ParseExpr(pos);
}
int getSafety(Expression *expr) {
  if (expr == nullptr) return 5;
  if (expr->safety == 0) return 0;
  if (expr->type == Expression::VARI) return expr->safety;
  auto lSafety = getSafety(expr->lexpr);
  auto rSafety = getSafety(expr->rexpr);
  if (lSafety == 0 || rSafety == 0) return expr->safety = 0;
  if (expr->value[0] == '+') return expr->safety;
  if (expr->value[0] == '-') {
    if (rSafety <= 2) expr->safety = 0;
    return expr->safety;
  }
  if (expr->value[0] == '*') {
    if (rSafety <= 2 || lSafety <= 2) expr->safety = 0;
    return expr->safety;
  }
  if (expr->value[0] == '/') {
    if (rSafety <= 4 || lSafety <= 2) expr->safety = 0;
    return expr->safety;
  }
  return 0;
}
int main() {
  int n;
  string s;
  cin >> n;
  getline(cin, s);
  for (int i = 0; i < n; i++) {
    getline(cin, s);
    stringstream ss(s);
    char c;
    while (ss >> c)
      if (c == '#') break;
    string name;
    ss >> name;
    ss >> name;
    string sExpr, t;
    while (ss >> t) sExpr += t;
    ::str = sExpr;
    Expression *expr = ParseExpr();
    safetyVal[name] = getSafety(expr);
    delete expr;
  }
  getline(cin, s);
  string sExpr;
  for (auto i : s) {
    if (i != ' ') sExpr.push_back(i);
  }
  ::str = sExpr;
  Expression *expr = ParseExpr();
  io.WL(getSafety(expr) ? "OK" : "Suspicious");
  delete expr;
  return 0;
}