public final NiklausParser.multiplicationexpression_return multiplicationexpression() throws RecognitionException {
        NiklausParser.multiplicationexpression_return retval = new NiklausParser.multiplicationexpression_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token MULTIPLICATION113=null;
        Token DIVISION115=null;
        NiklausParser.negationexpression_return negationexpression112 =null;

        NiklausParser.negationexpression_return negationexpression114 =null;

        NiklausParser.negationexpression_return negationexpression116 =null;


        CommonTree MULTIPLICATION113_tree=null;
        CommonTree DIVISION115_tree=null;

        try {
            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:148:25: ( negationexpression ( ( MULTIPLICATION ^ negationexpression )+ | DIVISION ^ negationexpression )? )
            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:3: negationexpression ( ( MULTIPLICATION ^ negationexpression )+ | DIVISION ^ negationexpression )?
            {
            root_0 = (CommonTree)adaptor.nil();


            pushFollow(FOLLOW_negationexpression_in_multiplicationexpression837);
            negationexpression112=negationexpression();

            state._fsp--;

            adaptor.addChild(root_0, negationexpression112.getTree());

            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:22: ( ( MULTIPLICATION ^ negationexpression )+ | DIVISION ^ negationexpression )?
            int alt30=3;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==MULTIPLICATION) ) {
                alt30=1;
            }
            else if ( (LA30_0==DIVISION) ) {
                alt30=2;
            }
            switch (alt30) {
                case 1 :
                    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:23: ( MULTIPLICATION ^ negationexpression )+
                    {
                    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:23: ( MULTIPLICATION ^ negationexpression )+
                    int cnt29=0;
                    loop29:
                    do {
                        int alt29=2;
                        int LA29_0 = input.LA(1);

                        if ( (LA29_0==MULTIPLICATION) ) {
                            alt29=1;
                        }


                        switch (alt29) {
                    	case 1 :
                    	    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:24: MULTIPLICATION ^ negationexpression
                    	    {
                    	    MULTIPLICATION113=(Token)match(input,MULTIPLICATION,FOLLOW_MULTIPLICATION_in_multiplicationexpression841); 
                    	    MULTIPLICATION113_tree = 
                    	    (CommonTree)adaptor.create(MULTIPLICATION113)
                    	    ;
                    	    root_0 = (CommonTree)adaptor.becomeRoot(MULTIPLICATION113_tree, root_0);


                    	    pushFollow(FOLLOW_negationexpression_in_multiplicationexpression844);
                    	    negationexpression114=negationexpression();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, negationexpression114.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt29 >= 1 ) break loop29;
                                EarlyExitException eee =
                                    new EarlyExitException(29, input);
                                throw eee;
                        }
                        cnt29++;
                    } while (true);


                    }
                    break;
                case 2 :
                    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:149:64: DIVISION ^ negationexpression
                    {
                    DIVISION115=(Token)match(input,DIVISION,FOLLOW_DIVISION_in_multiplicationexpression851); 
                    DIVISION115_tree = 
                    (CommonTree)adaptor.create(DIVISION115)
                    ;
                    root_0 = (CommonTree)adaptor.becomeRoot(DIVISION115_tree, root_0);


                    pushFollow(FOLLOW_negationexpression_in_multiplicationexpression854);
                    negationexpression116=negationexpression();

                    state._fsp--;

                    adaptor.addChild(root_0, negationexpression116.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }