/**
* Created by sher on 19.04.15.
*/
import java.util.*;
class Parser {
public static Map<String, Integer> vars = new Hashtable<>();
public List<String> depends = new ArrayList<>();
public String name;
public int n;
private Deque<String> lexems;
int mark = 1;
public List<Parser> edges = new ArrayList<>();
Parser(Deque<String> y, int n, String name) {
lexems = y;
this.n = n;
this.name = name;
}
public void parse() throws Exception {
int x = parseVars();
if (x < 1) {
throw new RuntimeException();
}
while (lexems.size() != 0) {
parseExpr();
String lx = lexems.poll();
if (lx != null && (!lx.equals(",") || lexems.size() == 0)) {
throw new RuntimeException();
}
x--;
}
if (x != 0) {
throw new RuntimeException();
}
}
private int parseVars() {
String lx;
int ans = 0;
if (!Character.isLetter((lx = lexems.poll()).charAt(0))) {
throw new RuntimeException();
}
while (!lx.equals("=")) {
if (Character.isLetter(lx.charAt(0))) {
if (vars.put(lx, n) != null) {
throw new RuntimeException();
}
ans++;
} else if (lx.equals(",") && Character.isLetter(lexems.peek().charAt(0))) {
} else {
throw new RuntimeException();
}
lx = lexems.poll();
}
return ans;
}
private void parseExpr() throws Exception {
parseTerm();
for (; lexems.size() != 0 && (lexems.peek().equals("+") || lexems.peek().equals("-")); ) {
lexems.poll();
parseTerm();
}
}
private void parseTerm() throws Exception {
parsePower();
for (; lexems.size() != 0 && (lexems.peek().equals("*") || lexems.peek().equals("/")); ) {
lexems.poll();
parsePower();
}
}
private void parsePower() throws Exception {
String lx = lexems.poll();
if (Character.isDigit(lx.charAt(0)))
return;
else if (Character.isLetter(lx.charAt(0)))
depends.add(lx);
else if (lx.equals("-"))
parsePower();
else if (lx.equals("(")) {
parseExpr();
if (!lexems.poll().equals(")"))
throw new Exception("Expected ')'");
} else
throw new Exception("Bad lexem: " + lx);
}
public String toString() { return name; }
}
public class FormulaOrder {
private static Map<String, Integer> vars = new Hashtable<>();
private static Scanner in = new Scanner(System.in);
private static Deque<String> lexer(String expr) {
Deque<String> lexems = new ArrayDeque<>();
for (int i = 0; i < expr.length(); i++) {
char c = expr.charAt(i);
if (c == ' ')
continue;
else if (Character.isLetterOrDigit(c)) {
String token = new String();
for (; Character.isLetterOrDigit(c); i++, c = expr.charAt(i)) { token += (c + ""); }
lexems.add(token);
i--;
} else
lexems.add(Character.toString(c));
}
return lexems;
}
static void dfs(Parser v, List<Parser> ans) {
v.mark = 0;
for (Parser u : v.edges) {
if (u.mark == 0) {
System.out.println("cycle");
System.exit(0);
} else if (u.mark == 1) {
dfs(u, ans);
}
}
v.mark = -1;
ans.add(v);
}
public static void main(String args[]) {
List<Parser> g = new ArrayList<>();
int i;
for (i = 0; in.hasNextLine(); i++) {
String expr = in.nextLine() + " ";
Deque<String> lexems = lexer(expr);
g.add(new Parser(lexems, i, expr));
vars.put(expr.split("=")[0], i);
try {
g.get(g.size() - 1).parse();
} catch (Exception e) {
System.out.print("syntax error");
System.exit(0);
}
}
try {
for (Parser x : g) {
// System.out.print(x + " : ");
for (String y : x.depends) {
x.edges.add(g.get(Parser.vars.get(y)));
}
// System.out.println(x.depends);
}
} catch (Exception r) {
System.out.println("syntax error");
System.exit(0);
}
List<Parser> ans = new ArrayList<>();
for (Parser v : g) {
if (v.mark == 1) {
dfs(v, ans);
}
}
for (Parser a : ans) {
System.out.println(a);
}
}
// public void dfs()
}