import java.lang.Exception;
import java.io.*;

public class Main {

    @SuppressWarnings("serial")
	public class SyntaxErrorException extends Exception {}

    BufferedReader r;
    Stack stack;

    Main() {
	stack = new Stack();
	r = new BufferedReader(new InputStreamReader(System.in));
    }

    public Symbol nextSymbol() throws SyntaxErrorException, IOException
    {
	String image;
	char c;
	{  
	    image = "";
	    while (Character.isSpaceChar((c = (char)r.read()))) { };
	    image = image + c;
	    if(c < ' ') 
		return new Symbol(SymbolTag.ENDINPUT,true);
	    else if(c=='f')
		return new Symbol(SymbolTag.FUNSYM,true); 
	    else if(c=='(')
		return new Symbol(SymbolTag.LPAR,true);
	    else if(c==')')
		return new Symbol(SymbolTag.RPAR,true);
	    else if(c==',')
		return new Symbol(SymbolTag.COMMA,true);
	    else if(c=='a')
		return new Symbol(SymbolTag.CONST,true);
	    else if(Character.isDigit(c))
		return new Symbol(SymbolTag.DIGIT,true);
	    else throw new SyntaxErrorException();
	}
    }

    public void parseInput() throws SyntaxErrorException, IOException
    {
	Symbol currentSymbol;
	Symbol stackSymbol;

	currentSymbol = nextSymbol();
	stack.push(new Symbol(SymbolTag.I,false));

	while (!(stack.isEmpty())) 
	    {
		stackSymbol = stack.top();
		if (stackSymbol.isTerminal()) {
		    if(stackSymbol.matches(currentSymbol)) {
			stack.pop();
			currentSymbol = nextSymbol();
		    } else throw new SyntaxErrorException();
		} else {

		    switch ( stackSymbol.getTag() ) {

		    case I : { switch ( currentSymbol.getTag() ) {
			    case FUNSYM : /* I -> S $ */ {
				stack.pop();
				stack.push(new Symbol(SymbolTag.S,false));
				break;
			    }
			    case CONST: /* I -> S $ */ {
				stack.pop();
				stack.push(new Symbol(SymbolTag.S,false));
				break;
			    }
			    default: throw new SyntaxErrorException();
			    }
			    break;
		    }

		    case DR:{switch ( currentSymbol.getTag() ) {
			    case DIGIT: /* DR -> <DIGIT> DR  */ {
				stack.pop();
				stack.push(new Symbol(SymbolTag.DR,false));
				stack.push(new Symbol(SymbolTag.DIGIT,true));
				break;
			    }
			    case LPAR: /* DR -> empty  */ {
				stack.pop();
				break;
			    }
			    default: throw new SyntaxErrorException();
			    }
			    break;
		    }

		    case S:{
			switch ( currentSymbol.getTag() ) {
			case FUNSYM : /* S -> <f> D <(> ARGS <)>  */ {
			    stack.pop();
			    stack.push(new Symbol(SymbolTag.RPAR,true));
			    stack.push(new Symbol(SymbolTag.ARGS,false));
			    stack.push(new Symbol(SymbolTag.LPAR,true));
			    stack.push(new Symbol(SymbolTag.DR,false));
			    stack.push(new Symbol(SymbolTag.FUNSYM,true));
			    break;
			}
			case CONST: /* S -> <CONST> */ {
			    stack.pop();
			    stack.push(new Symbol(SymbolTag.CONST,true));
			    break;
			}
			default: throw new SyntaxErrorException();
			};
			break;
		    }

		    case ARGS:{
			switch ( currentSymbol.getTag() ) {
			case RPAR : /* ARGS -> empty  */ {
			    stack.pop();
			    break;
			}

			case FUNSYM: /* ARGS -> S ARGR */ {
			    stack.pop();
			    stack.push(new Symbol(SymbolTag.ARGR,false));
			    stack.push(new Symbol(SymbolTag.S,false));
			    break;
			}
			case CONST: /* ARGS -> S ARGR */ {
			    stack.pop();
			    stack.push(new Symbol(SymbolTag.ARGR,false));
			    stack.push(new Symbol(SymbolTag.S,false));
			    break;
			}

			default: throw new SyntaxErrorException();
			}
			break;
		    }

		    case ARGR:{
			switch ( currentSymbol.getTag() ) {
			case RPAR : /* ARGR -> empty  */ {
			    stack.pop();
			    break;
			}
			case COMMA: /* ARGS -> <COMMA> S ARGR */ {
			    stack.pop();
			    stack.push(new Symbol(SymbolTag.ARGR,false));
			    stack.push(new Symbol(SymbolTag.S,false));
			    stack.push(new Symbol(SymbolTag.COMMA,true));
			    break;
			}
			default: throw new SyntaxErrorException();
			}
			break;
		    }
		    }
		}
	    }
	if(currentSymbol.getTag()!=SymbolTag.ENDINPUT)
	    throw new SyntaxErrorException();
    }

    static public void main(String[] args) throws Exception {

	Main parser = new Main();
	try {
	    parser.parseInput();
	    System.out.println("Accepted");
	} catch (SyntaxErrorException e) 
	    {System.out.println("Syntax Error"); }
    }

}