import  java.io.*;
 import  java.util.*;

 public   class  Minim {

     public  Minim() {
    }

     public   static  String extractBlock(StringBuffer buffer) {
         char  chars[] = buffer.toString().toCharArray();
         int  leftP =  0 ;
         int  rightP =  0 ;
         int  firstLeft =  0 ;
         for  ( int  i =  0 ; i < chars.length; i++) {
             if  (chars[i] == LEFT_BRACE) {
                 if  (leftP ==  0 ) {
                    firstLeft = i;
                }
                leftP++;
            }  else   if  (chars[i] == RIGHT_BRACE) {
                rightP++;
            }
             if  (leftP >  0  && leftP == rightP) {
                 char [] resultArray =  new   char [i -  1  - firstLeft];
                System.arraycopy(chars,  1  + firstLeft, resultArray,  0 ,
                                 i -  1  - firstLeft);
                buffer.replace( 0 , i +  1 , "");
                 return   new  String(resultArray);
            }
        }
         return   null ;
    }


     public   void  execFromFile(String fileName)  throws  IOException, MException {
        File file =  new  File(fileName);
        BufferedReader reader =  new  BufferedReader( new  FileReader(file));

        StringBuffer text =  new  StringBuffer();
        String line =  null ;

         while  ((line = reader.readLine()) !=  null ) {
            text.append(line.trim()).append(" ");
        }

        exec(text);
    }

     private   final   static   char  LEFT_BRACE = '(';
     private   final   static   char  RIGHT_BRACE = ')';
     private   final   static   char  STRING_DELIMITER = '"';


     public   void  exec(StringBuffer programText)  throws  MException {
        System.out.println("launch program ... " + programText);
        MinimProcessor processor =  new  MinimProcessor(programText.toString(),
                System.out,  new  Scanner(System.in));
        processor.execute();
    }

     public   static   void  main(String args[])  throws  Exception {
         if  (args.length !=  1 ) {
            System.out.println("Use Minim <filename>");
             return ;
        }  else  {
            Minim minim =  new  Minim();
            minim.execFromFile(args[ 0 ]);
        }
    }

     private   class  MinimProcessor {

         private  StringBuffer text;
         private  PrintStream out;
         private  Scanner in;
         private  Collection<MinimProgram> programs =  new  ArrayList<MinimProgram>();

         public  MinimProcessor(String text, PrintStream out, Scanner in)  throws 
                MCompileException {
             this .text =  new  StringBuffer(text);
             this .out = out;
             this .in = in;

             this .preProcess();
        }


         private   void  preProcess()  throws  MCompileException {
            System.out.println("Preprocessing...");
            String block =  null ;
             while  ((block = Minim.extractBlock(text)) !=  null ) {
                programs.add( new  MinimProgram(block, out, in));
            }
        }


         public   void  execute()  throws  MExecException {
             if  (programs.size() ==  0 ) {
                 throw   new  MExecException("There are no programs to execute.");
            }
            System.out.println("Executing...");
             long  time = System.currentTimeMillis();
             for  (MinimProgram program : programs) {
                program.execute();
            }
            System.out.println("Program successfully executed in " +
                               (System.currentTimeMillis() - time) + " msec");
        }
    }


     private   class  MinimProgram {

         private  List<Command> executionLines =  new  ArrayList<Command>();

         private  Command[] commands =  null ;

         private  Map<String, Integer> tags =  new  HashMap<String, Integer>();
         private  Set<String> multipleTags =  new  HashSet<String>();

         private  List< Double > variables =  new  ArrayList< Double >();
         private  Map<String, Integer> varPositions =  new  HashMap<String, Integer>();


         private   Double [] vars =  null ;

         private  String text;
         private  PrintStream out;
         private  Scanner in;


         private   long  MAX_ITERATIONS =  100000000 ;

         private  CommandBuilder builder =  new  CommandBuilder( this );

         public  MinimProgram(String text, PrintStream out, Scanner in)  throws 
                MCompileException {
             this .out = out;
             this .in = in;
             this .text = text;
             this .preCompile();
             this .postCompile();
        }

         long  time;
         public   void  startTick() {
            time = System.currentTimeMillis();
        }

         long  pause;
         public   void  pauseTick() {
            pause = System.currentTimeMillis();
        }

         public   void  resumeTick() {
            time += (System.currentTimeMillis() - pause);
        }

         public   long  stopTick() {
             return  (System.currentTimeMillis() - time);
        }

         public   void  preCompile()  throws  MCompileException {
            System.out.println("Precompile");
             this .parseBlock( this .text);
        }

         public   void  parseBlock(String block)  throws  MCompileException {
             char  chars[] = block.toCharArray();
             int  leftP =  0 ;
             int  rightP =  0 ;

            StringBuffer result =  new  StringBuffer();
             for  ( int  i =  0 ; i < chars.length; i++) {
                 if  (chars[i] == LEFT_BRACE) {

                     if  (leftP ==  0 ) {
                        String res = result.toString().trim();
                         if  (res.length() >  0 ) {
                            createCommand(res, true);
                        }
                        result.delete( 0 , result.length());
                    }

                    leftP++;
                }  else   if  (chars[i] == RIGHT_BRACE) {
                    rightP++;
                }
                result.append(chars[i]);

                 if  (chars[i] == ' ' && leftP ==  0 ) {
                    String res = result.toString().trim();
                     if  (res.length() >  0 ) {
                        createCommand(res, true);
                    }
                    result.delete( 0 , result.length());

                }

                 if  (leftP >  0  && leftP == rightP) {

                    String res = result.toString().trim();
                    System.out.println("GO FOR " + res + " and " + leftP);
                     if  (res.length() >  0 ) {
                        createCommand(res.substring( 0 , res.length() -  1 ).
                                      substring( 1 ), false);
                    }
                    result.delete( 0 , result.length());
                    leftP =  0 ;
                    rightP =  0 ;
                }
            }

            String res = result.toString().trim();
             if  (res.length() >  0 ) {
                createCommand(res, true);
            }

        }


         public   int  createCommand(String text,  boolean  isTag)  throws 
                MCompileException {
             int  pos = appendCommand( null );
            builder.createCommand(pos, text, isTag);
             return  pos;
        }

         public   void  setCommand( int  pos, Command cmd) {
             this .executionLines.set(pos, cmd);
        }

         public   int  appendTag(String tagName) {
            tagName = tagName.toLowerCase();
            Integer pos =  new  Integer(executionLines.size() -  1 );
             if  (tags.containsKey(tagName)) {
                multipleTags.add(tagName);
            }
            tags.put(tagName, pos);
            System.out.println("APPEND TAG '" + tagName + "' as " + pos);
             return  pos.intValue();
        }

         public   int  registerCallableTag(String tagName)  throws  MCompileException {
            tagName = tagName.toLowerCase();
             if  (multipleTags.contains(tagName)) {
                 throw   new  MCompileException("Program refer to tag '" + tagName +
                                            "'. This tag presents more than one time in program. Unknown destination.");
            }
            Integer pos = tags.get(tagName);
             if  (pos ==  null ) {
                 throw   new  MCompileException("Program refer to tag '" + tagName +
                                            "'. This tag is not defined. Unknown destination.");

            }
             return  pos.intValue();
        }

         public   int  appendVariable(String variable,  boolean  asInput) {
             if  (variable.length() ==  0 ) {
                 throw   new  RuntimeException("Variable is empty");
            }
            variable = variable.toLowerCase();
            Integer pos = varPositions.get(variable);
             if  (pos ==  null ) {
                variables.add(asInput ?  new   Double ( 0 ) :  null );
                pos =  new  Integer(variables.size() -  1 );
                varPositions.put(variable, pos);
            }
            System.out.println("VAR '" + variable + "' : " + pos.intValue() +
                               " :: " + asInput);
             return  pos.intValue();
        }

         public   double  getVariable( int  pos) {
             return  vars[pos].doubleValue();
        }

         public   void  setVariable( int  pos,  double  value) {
            vars[pos] =  Double .valueOf(value);
        }


         public   int  appendCommand(Command command) {
            executionLines.add(command);
             return  executionLines.size() -  1 ;
        }


         public   void  postCompile()  throws  MCompileException {
            System.out.println("Postcompile");

             for  (Map.Entry<String, Integer> entry : varPositions.entrySet()) {
                 if  (variables.get(entry.getValue().intValue()) ==  null ) {
                     throw   new  MCompileException(
                            "Error in variable " + entry.getKey() +
                            ". This variable is not initialized");
                }
            }

            commands = (Command[]) executionLines.toArray( new  Command[ 0 ]);
            vars = ( Double []) variables.toArray( new   Double [ 0 ]);

             for  ( int  i =  0 ; i < commands.length; i++) {
                 if  (commands[i] !=  null ) {
                    commands[i].postCompile();
                }
            }

            // clear cache
            executionLines.clear();
            variables.clear();
            tags.clear();
            varPositions.clear();
            multipleTags.clear();
        }

         public   void  execute()  throws  MExecException {
            System.out.println("Executing");
             int  globalIndex =  0 ;
             int  maxLength = commands.length;

             this .startTick();

             int  iterations =  0 ;
             boolean  anyCmd = false;
             for  (globalIndex =  0 ; globalIndex < maxLength; globalIndex++) {
                Command cmd = commands[globalIndex];
                 if  (cmd !=  null ) {
                    anyCmd = true;
                     if  (cmd.execute()) {
                        globalIndex = cmd.getRedirect();
                         if  (globalIndex <  0 ) {
                             throw   new  MExecException(
                                    "Exception during program run. Destination index " +
                                    globalIndex + " unknown.");
                        }  else   if  (globalIndex >= maxLength) {
                             break ;
                        }

                    }
                }
                iterations++;
                 if  (iterations >= MAX_ITERATIONS) {
                     throw   new  MExecException("Program do more than " +
                                             MAX_ITERATIONS +
                                             " iterations and now over");
                }
            }

            System.out.println("Executed by " +  this .stopTick() + " msec");

             if  (!anyCmd) {
                 throw   new  MExecException(
                        "Command list is empty. Nothing to execute.");
            }

        }
    }


     private   abstract   class  Command {

         public   int  getRedirect() {
             return  - 1 ;
        }

         public   abstract   boolean  execute()  throws  MExecException;

        MinimProgram program;
         public   void  setProgram(MinimProgram program) {
             this .program = program;
        }

         public   abstract   void  init(String data)  throws  MCompileException;

         public   void  postCompile()  throws  MCompileException {
            //
        }
    }


     private   class  CommandNewLine  extends  Command {
         public   boolean  execute() {
            program.out.println();
             return  false;
        }

         public   void  init(String data) {
            //
        }

    }


     private   class  CommandPrint  extends  Command {

         private   boolean  static_;

         private  String data;
         private   int  variable;

         public   boolean  execute() {

             if  (static_) {
                program.out.print(data);
            }  else  {
                program.out.print(program.getVariable(variable));
            }
             return  false;
        }

         public   void  init(String data) {
             if  (data.charAt( 0 ) == STRING_DELIMITER) {
                static_ = true;
                 this .data = data.substring( 1 );
                 if  ( this .data.charAt( this .data.length() -  1 ) ==
                    STRING_DELIMITER) {
                     this .data =  this .data.substring( 0 ,  this .data.length() -  1 );
                }
            }  else  {
                 try  {
                     double  constant =  Double .parseDouble(data);
                     this .data = data;
                    static_ = true;
                }  catch  (NumberFormatException nfe) {
                    static_ = false;
                    variable = program.appendVariable(data, false);
                }
            }
        }
    }


     private   class  CommandInput  extends  Command {
         int  variable;

         public   boolean  execute() {
            program.pauseTick();
             double  data = program.in.nextDouble();
            program.resumeTick();
            program.setVariable(variable, data);
             return  false;
        }

         public   void  init(String data) {
            variable = program.appendVariable(data, true);
        }
    }


     private   class  CommandPlus  extends  CommandInput {
         public   boolean  execute() {
            program.setVariable(variable, program.getVariable(variable) +  1 );
             return  false;
        }
    }


     private   class  CommandMinus  extends  CommandPlus {
         public   boolean  execute() {
            program.setVariable(variable, program.getVariable(variable) -  1 );
             return  false;
        }
    }


     private   class  CommandAssign  extends  Command {
         public   boolean  execute() {
             if  (static_) {
                program.setVariable(leftSide, right);
            }  else  {
                program.setVariable(leftSide, program.getVariable(rightSide));
            }
             return  false;
        }

         public   void  init(String data)  throws  MCompileException {
             int  space = data.indexOf(" ");
            String left = data.substring( 0 , space).trim();
            String right = data.substring(space +  1 ).trim();

             try  {
                 double  tmp =  Double .parseDouble(left);
                 throw   new  MCompileException("Left side of assignment '" + data +
                                            "' is not an variable: " + left);
            }  catch  (NumberFormatException nfe) {
            }

            leftSide = program.appendVariable(left, true);
             try  {
                 this .right =  Double .parseDouble(right);
                static_ = true;
            }  catch  (NumberFormatException nfe) {
                static_ = false;
                rightSide = program.appendVariable(right, false);
            }

        }

         int  leftSide;
         int  rightSide;
         double  right;
         boolean  static_;

    }


     private   class  CommandGoto  extends  Command {
         public   boolean  execute() {
             return  true;
        }

         public   int  getRedirect() {
             return  label;
        }

         public   void  init(String data)  throws  MCompileException {
            textLabel = data;
        }

         public   void  postCompile()  throws  MCompileException {
             this .label = program.registerCallableTag(textLabel);
        }

        String textLabel;
         int  label;
    }


     private   class  CommandIf  extends  Command {

         public   boolean  execute()  throws  MExecException {
            isTrue_ = condition.getCondition();
             return  true;
        }

         public   int  getRedirect() {
             return  isTrue_ ? labelTrue : labelFalse;
        }

         public   void  init(String data)  throws  MCompileException {
            StringBuffer buf =  new  StringBuffer(data);
            String condition = Minim.extractBlock(buf);
             int  brace = buf.indexOf(String.valueOf(LEFT_BRACE));
             if  (brace <=  0 ) {
                 throw   new  MCompileException("Unable to parse IF condition '" +
                                            data + "'. Can't find symbol " +
                                            LEFT_BRACE +
                                            " in properly position");
            }
            System.out.println("CONDITION = " + condition);
            String then_ = buf.substring(0, brace);
            if (!then_.trim().toLowerCase().equals("then")) {
                throw new MCompileException("Unable to parse IF condition '" +
                                            data + "'. Can't find 'then'");

            }
            buf.delete( 0 , brace);
             int  elsePos = buf.indexOf("else");
             if  (elsePos <=  0 ) {
                 throw   new  MCompileException("Unable to parse IF condition '" +
                                            data +
                                            "'. Can't find 'else' in properly position");
            }

            String s = buf.substring(0, elsePos);
            if (s.indexOf(String.valueOf(LEFT_BRACE)) >= 0) {
                String trueCondition = Minim.extractBlock(buf);
                labelTrue = program.appendTag(String.valueOf(this.hashCode()) +
                                              "@tr");
                System.out.println("CREATE TRUE CONDITION = " + trueCondition);
                program.parseBlock(LEFT_BRACE + trueCondition + RIGHT_BRACE);

            } else {
                labelTrue = program.appendTag(s.trim());
                buf.delete(0, elsePos);
            }
            program.createCommand("goto " + this.hashCode(), false);

            String else_ = buf.toString().trim();
            if (!else_.startsWith("else")) {
                throw new MCompileException("Unable to parse IF condition '" +
                                            data + "'. Can't find 'else'");

            }
            buf.delete( 0 ,  5 );
             if  (buf.indexOf(String.valueOf(LEFT_BRACE)) >=  0 ) {
                String falseCondition = Minim.extractBlock(buf);
                System.out.println("CREATE FALSE CONDITION = " + falseCondition);
                labelFalse = program.appendTag(String.valueOf( this .hashCode()) +
                                               "@fls");
                program.parseBlock(LEFT_BRACE + falseCondition +
                                   RIGHT_BRACE);

            }  else  {
                labelFalse = program.appendTag(buf.toString().trim());
            }

            program.appendTag(String.valueOf( this .hashCode()));

             this .condition =  new  Condition(condition);
        }

        Condition condition;
         boolean  isTrue_ = false;
         int  labelTrue;
         int  labelFalse;

         private   class  Condition {
             public  Condition(String data)  throws  MCompileException {
                 int  pos = data.indexOf(' ');
                String left = data.substring( 0 , pos);
                 if  (left.trim().length() ==  0 ) {
                     throw   new  MCompileException(
                            "Unable to extract left side of condition '" + data +
                            "'");
                }

                 int  pos2 = data.lastIndexOf(' ');
                String right = data.substring(pos2 +  1 );
                 if  (right.trim().length() ==  0 ) {
                     throw   new  MCompileException(
                            "Unable to extract right side of condition '" +
                            data +
                            "'");
                }

                String operator = data.substring(pos +  1 , pos2).trim();
                 if  (operator.equals("<")) {
                    operation = '<';
                }  else 
                 if  (operator.equals(">")) {
                    operation = '>';
                }  else 
                 if  (operator.equals("=")) {
                    operation = '=';
                }  else  {
                     throw   new  MCompileException("Unknown operator '" + operator +
                                                "' in condition '" + data + "'");
                }

                 try  {
                     this .left =  Double .parseDouble(left);
                    left_static_ = true;
                }  catch  (NumberFormatException nfe) {
                    leftSide = program.appendVariable(left, false);
                }

                 try  {
                     this .right =  Double .parseDouble(right);
                    right_static_ = true;
                }  catch  (NumberFormatException nfe) {
                    rightSide = program.appendVariable(right, false);
                }

            }

             public   boolean  getCondition()  throws  MExecException {
                 if  (!left_static_) {
                    left = program.getVariable(leftSide);
                }
                 if  (!right_static_) {
                    right = program.getVariable(rightSide);
                }
                 switch  (operation) {
                 case  '<':
                     return  left < right;
                 case  '>':
                     return  left > right;
                 case  '=':
                     return  left == right;
                 default :
                     throw   new  MExecException("Unknown operation '" + operation +
                                             "'");

                }
            }

             int  leftSide;
             int  rightSide;

             double  left;
             double  right;

             char  operation;

             boolean  left_static_;
             boolean  right_static_;


        }

    }


     private   class  CommandBuilder {

         private  MinimProgram program;


         public  CommandBuilder(MinimProgram program) {
             this .program = program;
        }

         private   final   static  String COMMAND_PRINT = "print ";
         private   final   static  String COMMAND_INPUT = "input ";
         private   final   static  String COMMAND_SUB = "-- ";
         private   final   static  String COMMAND_PLUS = "++ ";
         private   final   static  String COMMAND_IS = " is ";
         private   final   static  String COMMAND_GOTO = "goto ";
         private   final   static  String NL = "nl";
         private   final   static  String COMMAND_IF = "if ";

         private   void  createCommand( int  pos, String text,  boolean  isTag)  throws 
                MCompileException {

            System.out.println("Processing cmd '" + text + "' at " + pos +
                               " and isTag ? " + isTag);

            Command command =  null ;
            String data =  null ;
            text = text.trim();
            String cmd = text.toLowerCase();
             if  (isTag) {
                 if  (cmd.equals(NL)) {
                    command =  new  CommandNewLine();
                    data =  null ;
                }  else  {
                    program.appendTag(text);
                }
            }  else  {
                 int  txtPos =  0 ;
                 if  (cmd.startsWith(COMMAND_PRINT)) {
                    command =  new  CommandPrint();
                    data = text.substring(COMMAND_PRINT.length());
                }  else   if  (cmd.startsWith(COMMAND_INPUT)) {
                    command =  new  CommandInput();
                    data = text.substring(COMMAND_INPUT.length());
                }  else   if  (cmd.startsWith(COMMAND_SUB)) {
                    command =  new  CommandMinus();
                    data = text.substring(COMMAND_SUB.length());
                }  else   if  (cmd.startsWith(COMMAND_PLUS)) {
                    command =  new  CommandPlus();
                    data = text.substring(COMMAND_PLUS.length());
                }  else   if  (cmd.startsWith(COMMAND_GOTO)) {
                    command =  new  CommandGoto();
                    data = text.substring(COMMAND_GOTO.length());
                }  else   if  ((txtPos = cmd.indexOf(COMMAND_IS)) >  0 ) {
                    command =  new  CommandAssign();
                    data = text.substring( 0 , txtPos) +
                           text.substring(txtPos + COMMAND_IS.length() -  1 );
                }  else   if  (cmd.startsWith(COMMAND_IF)) {
                    command =  new  CommandIf();
                    data = text.substring(COMMAND_IF.length());
                }  else  {
                     throw   new  MUnknownException("Unable to recognize command " +
                                                text);
                }
            }
             if  (command !=  null ) {
                System.out.println("init for cmd " + command + " = " + data);
                command.setProgram(program);
                command.init(data);

                program.setCommand(pos, command);
            }
        }
    }
}


 class  MException  extends  Exception {
     public  MException(String message) {
         super (message);
    }
}


 class  MExecException  extends  MException {
     public  MExecException(String message) {
         super (message);
    }
}


 class  MCompileException  extends  MException {
     public  MCompileException(String message) {
         super (message);
    }
}


 class  MUnknownException  extends  MCompileException {
     public  MUnknownException(String message) {
         super (message);
    }
}

(
(print "Add x and y")
nl
(print "Input x: ")
(input x)
nl
(print "Input y: ")
(input y)
main
(if (x =  0 ) then (goto end) else (goto subx1))

subx1
(-- x)
(++ y)
(goto main)

end
nl
(print "total of x and y is ")
(print y)
nl)

launch program ... ( (print "Add x and y") nl (print "Input x: ") (input x) nl (print "Input y: ") (input y) main (if (x =  0 ) then (goto end) else (goto subx1))  subx1 (-- x) (++ y) (goto main)  end nl (print "total of x and y is ") (print y) nl) 
Preprocessing...
Executing...
Add x and y
Input x:  100000 

Input y:  100000 

total of x and y is  200000 . 0 
Executed by  47  msec
Program successfully executed in  3234  msec

launch program ... ( (print "Add x and y") nl (print "Input x: ") (input x) nl (print "Input y: ") (input y) main (if (x =  0 ) then (goto end) else (goto subx1))  subx1 (-- x) (++ y) (goto main)  end nl (print "total of x and y is ") (print y) nl) 
Preprocessing...
Executing...
Add x and y
Input x:  1000000 

Input y:  1000000 

total of x and y is  2000000 . 0 
Executed by  281  msec
Program successfully executed in  3641  msec