OoasTools

// $ANTLR 3.4 C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g 2015-03-30 18:21:33

/*

    Ulysses OO-Action System Parser

    Copyright Graz University of Technology 2009

    Copyright AIT Austrian Institute of Technology 2013

 */

 package org.momut.ooas.parser;

import org.antlr.runtime.*;

import java.util.Stack;

import java.util.List;

import java.util.ArrayList;

import java.util.Map;

import java.util.HashMap;

@SuppressWarnings({"all", "warnings", "unchecked"})

public class ooaLexer extends Lexer {

    public static final int EOF=-1;

    public static final int T__118=118;

    public static final int T__119=119;

    public static final int T__120=120;

    public static final int T__121=121;

    public static final int T__122=122;

    public static final int T__123=123;

    public static final int T__124=124;

    public static final int T__125=125;

    public static final int T__126=126;

    public static final int T__127=127;

    public static final int FLOAT_OR_INT_OR_RANGE=4;

    public static final int LINE_COMMENT=5;

    public static final int T_ABORT=6;

    public static final int T_ABS=7;

    public static final int T_ACTIONS=8;

    public static final int T_AND=9;

    public static final int T_ASSIGNMENT=10;

    public static final int T_AUTOCONS=11;

    public static final int T_BAR=12;

    public static final int T_BIIMPLIES=13;

    public static final int T_BOOL=14;

    public static final int T_BREAK=15;

    public static final int T_CARD=16;

    public static final int T_CBRL=17;

    public static final int T_CBRR=18;

    public static final int T_CHAR=19;

    public static final int T_COLON=20;

    public static final int T_COMMA=21;

    public static final int T_COMMENT=22;

    public static final int T_CONC=23;

    public static final int T_CONSTS=24;

    public static final int T_CONT=25;

    public static final int T_CTRL=26;

    public static final int T_DCONC=27;

    public static final int T_DERIV=28;

    public static final int T_DIFF=29;

    public static final int T_DIGIT=30;

    public static final int T_DINTER=31;

    public static final int T_DIV=32;

    public static final int T_DO=33;

    public static final int T_DOM=34;

    public static final int T_DOMRESBY=35;

    public static final int T_DOMRESTO=36;

    public static final int T_DUNION=37;

    public static final int T_ELEMS=38;

    public static final int T_ELSE=39;

    public static final int T_END=40;

    public static final int T_EQUAL=41;

    public static final int T_EXISTS=42;

    public static final int T_FALSE=43;

    public static final int T_FLOAT=44;

    public static final int T_FLOATNUMBER=45;

    public static final int T_FOLDLR=46;

    public static final int T_FOLDRL=47;

    public static final int T_FORALL=48;

    public static final int T_GREATER=49;

    public static final int T_GREATEREQUAL=50;

    public static final int T_HEAD=51;

    public static final int T_IDENTIFIER=52;

    public static final int T_IDIV=53;

    public static final int T_IF=54;

    public static final int T_IMPLIES=55;

    public static final int T_IN=56;

    public static final int T_INDS=57;

    public static final int T_INFTY=58;

    public static final int T_INT=59;

    public static final int T_INTER=60;

    public static final int T_INTNUMBER=61;

    public static final int T_KILL=62;

    public static final int T_LEN=63;

    public static final int T_LESS=64;

    public static final int T_LESSEQUAL=65;

    public static final int T_LETTER=66;

    public static final int T_LIST=67;

    public static final int T_LPAREN=68;

    public static final int T_LSQPAREN=69;

    public static final int T_MAP=70;

    public static final int T_MAPS=71;

    public static final int T_MERGE=72;

    public static final int T_METHODS=73;

    public static final int T_MINUS=74;

    public static final int T_MOD=75;

    public static final int T_MUNION=76;

    public static final int T_NEW=77;

    public static final int T_NIL=78;

    public static final int T_NONDET=79;

    public static final int T_NOT=80;

    public static final int T_NOTEQUAL=81;

    public static final int T_OBS=82;

    public static final int T_OD=83;

    public static final int T_OF=84;

    public static final int T_OR=85;

    public static final int T_POINT=86;

    public static final int T_POW=87;

    public static final int T_PRIMED=88;

    public static final int T_PRIO=89;

    public static final int T_PROD=90;

    public static final int T_QUANTITY=91;

    public static final int T_RANGETO=92;

    public static final int T_REQUIRES=93;

    public static final int T_RNG=94;

    public static final int T_RNGRESBY=95;

    public static final int T_RNGRESTO=96;

    public static final int T_RPAREN=97;

    public static final int T_RSQPAREN=98;

    public static final int T_SELF=99;

    public static final int T_SEMICOLON=100;

    public static final int T_SEQMOD_MAPOVERRIDE=101;

    public static final int T_SET=102;

    public static final int T_SKIP=103;

    public static final int T_STATIC=104;

    public static final int T_STRINGLITERAL=105;

    public static final int T_SUBSET=106;

    public static final int T_SUM=107;

    public static final int T_SYSTEM=108;

    public static final int T_TAIL=109;

    public static final int T_THEN=110;

    public static final int T_TO=111;

    public static final int T_TRUE=112;

    public static final int T_TYPES=113;

    public static final int T_UNION=114;

    public static final int T_VAR=115;

    public static final int T_WITH=116;

    public static final int T_WS=117;

    // delegates

    // delegators

    public Lexer[] getDelegates() {

        return new Lexer[] {};

    }

    public ooaLexer() {} 

    public ooaLexer(CharStream input) {

        this(input, new RecognizerSharedState());

    }

    public ooaLexer(CharStream input, RecognizerSharedState state) {

        super(input,state);

    }

    public String getGrammarFileName() { return "C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g"; }

    // $ANTLR start "T__118"

    public final void mT__118() throws RecognitionException {

        try {

            int _type = T__118;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:12:8: ( '&' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:12:10: '&'

            {

            match('&'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__118"

    // $ANTLR start "T__119"

    public final void mT__119() throws RecognitionException {

        try {

            int _type = T__119;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:13:8: ( '::' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:13:10: '::'

            {

            match("::"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__119"

    // $ANTLR start "T__120"

    public final void mT__120() throws RecognitionException {

        try {

            int _type = T__120;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:14:8: ( ']|' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:14:10: ']|'

            {

            match("]|"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__120"

    // $ANTLR start "T__121"

    public final void mT__121() throws RecognitionException {

        try {

            int _type = T__121;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:15:8: ( 'as' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:15:10: 'as'

            {

            match("as"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__121"

    // $ANTLR start "T__122"

    public final void mT__122() throws RecognitionException {

        try {

            int _type = T__122;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:16:8: ( 'begin' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:16:10: 'begin'

            {

            match("begin"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__122"

    // $ANTLR start "T__123"

    public final void mT__123() throws RecognitionException {

        try {

            int _type = T__123;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:17:8: ( 'dec' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:17:10: 'dec'

            {

            match("dec"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__123"

    // $ANTLR start "T__124"

    public final void mT__124() throws RecognitionException {

        try {

            int _type = T__124;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:18:8: ( 'inc' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:18:10: 'inc'

            {

            match("inc"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__124"

    // $ANTLR start "T__125"

    public final void mT__125() throws RecognitionException {

        try {

            int _type = T__125;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:19:8: ( 'qval' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:19:10: 'qval'

            {

            match("qval"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__125"

    // $ANTLR start "T__126"

    public final void mT__126() throws RecognitionException {

        try {

            int _type = T__126;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:20:8: ( 'steady' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:20:10: 'steady'

            {

            match("steady"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__126"

    // $ANTLR start "T__127"

    public final void mT__127() throws RecognitionException {

        try {

            int _type = T__127;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:21:8: ( '|[' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:21:10: '|['

            {

            match("|["); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T__127"

    // $ANTLR start "T_WS"

    public final void mT_WS() throws RecognitionException {

        try {

            int _type = T_WS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1030:8: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1030:10: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )

            {

            if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||(input.LA(1) >= '\f' && input.LA(1) <= '\r')||input.LA(1)==' ' ) {

                input.consume();

                state.failed=false;

            }

            else {

                if (state.backtracking>0) {state.failed=true; return ;}

                MismatchedSetException mse = new MismatchedSetException(null,input);

                recover(mse);

                throw mse;

            }

            if ( state.backtracking==0 ) {_channel=HIDDEN;}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_WS"

    // $ANTLR start "T_COMMENT"

    public final void mT_COMMENT() throws RecognitionException {

        try {

            int _type = T_COMMENT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1034:6: ( '/*' ( . )* '*/' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1034:8: '/*' ( . )* '*/'

            {

            match("/*"); if (state.failed) return ;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1034:13: ( . )*

            loop1:

            do {

                int alt1=2;

                int LA1_0 = input.LA(1);

                if ( (LA1_0=='*') ) {

                    int LA1_1 = input.LA(2);

                    if ( (LA1_1=='/') ) {

                        alt1=2;

                    }

                    else if ( ((LA1_1 >= '\u0000' && LA1_1 <= '.')||(LA1_1 >= '0' && LA1_1 <= '\uFFFF')) ) {

                        alt1=1;

                    }

                }

                else if ( ((LA1_0 >= '\u0000' && LA1_0 <= ')')||(LA1_0 >= '+' && LA1_0 <= '\uFFFF')) ) {

                    alt1=1;

                }

                switch (alt1) {

            	case 1 :

            	    // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1034:13: .

            	    {

            	    matchAny(); if (state.failed) return ;

            	    }

            	    break;

            	default :

            	    break loop1;

                }

            } while (true);

            match("*/"); if (state.failed) return ;

            if ( state.backtracking==0 ) {_channel=HIDDEN;}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_COMMENT"

    // $ANTLR start "LINE_COMMENT"

    public final void mLINE_COMMENT() throws RecognitionException {

        try {

            int _type = LINE_COMMENT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1038:6: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1038:8: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'

            {

            match('#'); if (state.failed) return ;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1038:12: (~ ( '\\n' | '\\r' ) )*

            loop2:

            do {

                int alt2=2;

                int LA2_0 = input.LA(1);

                if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\t')||(LA2_0 >= '\u000B' && LA2_0 <= '\f')||(LA2_0 >= '\u000E' && LA2_0 <= '\uFFFF')) ) {

                    alt2=1;

                }

                switch (alt2) {

            	case 1 :

            	    // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:

            	    {

            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) {

            	        input.consume();

            	        state.failed=false;

            	    }

            	    else {

            	        if (state.backtracking>0) {state.failed=true; return ;}

            	        MismatchedSetException mse = new MismatchedSetException(null,input);

            	        recover(mse);

            	        throw mse;

            	    }

            	    }

            	    break;

            	default :

            	    break loop2;

                }

            } while (true);

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1038:26: ( '\\r' )?

            int alt3=2;

            int LA3_0 = input.LA(1);

            if ( (LA3_0=='\r') ) {

                alt3=1;

            }

            switch (alt3) {

                case 1 :

                    // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1038:26: '\\r'

                    {

                    match('\r'); if (state.failed) return ;

                    }

                    break;

            }

            match('\n'); if (state.failed) return ;

            if ( state.backtracking==0 ) {_channel=HIDDEN;}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "LINE_COMMENT"

    // $ANTLR start "T_PRIMED"

    public final void mT_PRIMED() throws RecognitionException {

        try {

            int _type = T_PRIMED;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1042:2: ( '\\'' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1042:4: '\\''

            {

            match('\''); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_PRIMED"

    // $ANTLR start "T_STRINGLITERAL"

    public final void mT_STRINGLITERAL() throws RecognitionException {

        try {

            int _type = T_STRINGLITERAL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1045:2: ( '\"' ( ( '\"' '\"' )=> '\"' |~ '\"' )* '\"' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1045:4: '\"' ( ( '\"' '\"' )=> '\"' |~ '\"' )* '\"'

            {

            match('\"'); if (state.failed) return ;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1046:3: ( ( '\"' '\"' )=> '\"' |~ '\"' )*

            loop4:

            do {

                int alt4=3;

                int LA4_0 = input.LA(1);

                if ( (LA4_0=='\"') ) {

                    int LA4_1 = input.LA(2);

                    if ( (LA4_1=='\"') && (synpred1_ooa())) {

                        alt4=1;

                    }

                    else if ( ((LA4_1 >= '\u0000' && LA4_1 <= '!')||(LA4_1 >= '#' && LA4_1 <= '\uFFFF')) && (synpred1_ooa())) {

                        alt4=1;

                    }

                }

                else if ( ((LA4_0 >= '\u0000' && LA4_0 <= '!')||(LA4_0 >= '#' && LA4_0 <= '\uFFFF')) ) {

                    alt4=2;

                }

                switch (alt4) {

            	case 1 :

            	    // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1047:9: ( '\"' '\"' )=> '\"'

            	    {

            	    match('\"'); if (state.failed) return ;

            	    }

            	    break;

            	case 2 :

            	    // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1048:13: ~ '\"'

            	    {

            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {

            	        input.consume();

            	        state.failed=false;

            	    }

            	    else {

            	        if (state.backtracking>0) {state.failed=true; return ;}

            	        MismatchedSetException mse = new MismatchedSetException(null,input);

            	        recover(mse);

            	        throw mse;

            	    }

            	    }

            	    break;

            	default :

            	    break loop4;

                }

            } while (true);

            match('\"'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_STRINGLITERAL"

    // $ANTLR start "T_ABORT"

    public final void mT_ABORT() throws RecognitionException {

        try {

            int _type = T_ABORT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1054:9: ( 'abort' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1054:11: 'abort'

            {

            match("abort"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_ABORT"

    // $ANTLR start "T_ACTIONS"

    public final void mT_ACTIONS() throws RecognitionException {

        try {

            int _type = T_ACTIONS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1056:2: ( 'actions' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1056:4: 'actions'

            {

            match("actions"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_ACTIONS"

    // $ANTLR start "T_ASSIGNMENT"

    public final void mT_ASSIGNMENT() throws RecognitionException {

        try {

            int _type = T_ASSIGNMENT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1058:2: ( ':=' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1058:4: ':='

            {

            match(":="); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_ASSIGNMENT"

    // $ANTLR start "T_AUTOCONS"

    public final void mT_AUTOCONS() throws RecognitionException {

        try {

            int _type = T_AUTOCONS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1059:11: ( 'autocons' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1059:13: 'autocons'

            {

            match("autocons"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_AUTOCONS"

    // $ANTLR start "T_BAR"

    public final void mT_BAR() throws RecognitionException {

        try {

            int _type = T_BAR;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1060:7: ( '|' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1060:9: '|'

            {

            match('|'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_BAR"

    // $ANTLR start "T_BOOL"

    public final void mT_BOOL() throws RecognitionException {

        try {

            int _type = T_BOOL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1061:8: ( 'bool' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1061:10: 'bool'

            {

            match("bool"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_BOOL"

    // $ANTLR start "T_CBRL"

    public final void mT_CBRL() throws RecognitionException {

        try {

            int _type = T_CBRL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1062:8: ( '{' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1062:10: '{'

            {

            match('{'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_CBRL"

    // $ANTLR start "T_CBRR"

    public final void mT_CBRR() throws RecognitionException {

        try {

            int _type = T_CBRR;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1063:8: ( '}' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1063:10: '}'

            {

            match('}'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_CBRR"

    // $ANTLR start "T_COLON"

    public final void mT_COLON() throws RecognitionException {

        try {

            int _type = T_COLON;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1064:9: ( ':' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1064:11: ':'

            {

            match(':'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_COLON"

    // $ANTLR start "T_COMMA"

    public final void mT_COMMA() throws RecognitionException {

        try {

            int _type = T_COMMA;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1065:9: ( ',' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1065:11: ','

            {

            match(','); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_COMMA"

    // $ANTLR start "T_CONT"

    public final void mT_CONT() throws RecognitionException {

        try {

            int _type = T_CONT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1066:8: ( 'qual' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1066:10: 'qual'

            {

            match("qual"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_CONT"

    // $ANTLR start "T_CHAR"

    public final void mT_CHAR() throws RecognitionException {

        try {

            int _type = T_CHAR;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1067:8: ( 'char' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1067:10: 'char'

            {

            match("char"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_CHAR"

    // $ANTLR start "T_CTRL"

    public final void mT_CTRL() throws RecognitionException {

        try {

            int _type = T_CTRL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1068:9: ( 'ctr' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1068:11: 'ctr'

            {

            match("ctr"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_CTRL"

    // $ANTLR start "T_SYSTEM"

    public final void mT_SYSTEM() throws RecognitionException {

        try {

            int _type = T_SYSTEM;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1070:2: ( 'system' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1070:4: 'system'

            {

            match("system"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_SYSTEM"

    // $ANTLR start "T_DO"

    public final void mT_DO() throws RecognitionException {

        try {

            int _type = T_DO;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1071:6: ( 'do' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1071:8: 'do'

            {

            match("do"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_DO"

    // $ANTLR start "T_ELSE"

    public final void mT_ELSE() throws RecognitionException {

        try {

            int _type = T_ELSE;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1072:8: ( 'else' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1072:10: 'else'

            {

            match("else"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_ELSE"

    // $ANTLR start "T_END"

    public final void mT_END() throws RecognitionException {

        try {

            int _type = T_END;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1073:7: ( 'end' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1073:9: 'end'

            {

            match("end"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_END"

    // $ANTLR start "T_EQUAL"

    public final void mT_EQUAL() throws RecognitionException {

        try {

            int _type = T_EQUAL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1074:9: ( '=' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1074:11: '='

            {

            match('='); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_EQUAL"

    // $ANTLR start "T_EXISTS"

    public final void mT_EXISTS() throws RecognitionException {

        try {

            int _type = T_EXISTS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1075:9: ( 'exists' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1075:11: 'exists'

            {

            match("exists"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_EXISTS"

    // $ANTLR start "T_FLOAT"

    public final void mT_FLOAT() throws RecognitionException {

        try {

            int _type = T_FLOAT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1076:9: ( 'float' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1076:11: 'float'

            {

            match("float"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_FLOAT"

    // $ANTLR start "T_FORALL"

    public final void mT_FORALL() throws RecognitionException {

        try {

            int _type = T_FORALL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1077:9: ( 'forall' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1077:11: 'forall'

            {

            match("forall"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_FORALL"

    // $ANTLR start "T_FALSE"

    public final void mT_FALSE() throws RecognitionException {

        try {

            int _type = T_FALSE;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1078:9: ( 'false' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1078:11: 'false'

            {

            match("false"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_FALSE"

    // $ANTLR start "T_IF"

    public final void mT_IF() throws RecognitionException {

        try {

            int _type = T_IF;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1079:6: ( 'if' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1079:8: 'if'

            {

            match("if"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_IF"

    // $ANTLR start "T_IN"

    public final void mT_IN() throws RecognitionException {

        try {

            int _type = T_IN;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1080:6: ( 'in' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1080:8: 'in'

            {

            match("in"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_IN"

    // $ANTLR start "T_INT"

    public final void mT_INT() throws RecognitionException {

        try {

            int _type = T_INT;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1081:7: ( 'int' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1081:9: 'int'

            {

            match("int"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_INT"

    // $ANTLR start "T_KILL"

    public final void mT_KILL() throws RecognitionException {

        try {

            int _type = T_KILL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1082:8: ( 'kill' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1082:10: 'kill'

            {

            match("kill"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_KILL"

    // $ANTLR start "T_LIST"

    public final void mT_LIST() throws RecognitionException {

        try {

            int _type = T_LIST;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1083:8: ( 'list' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1083:10: 'list'

            {

            match("list"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_LIST"

    // $ANTLR start "T_LPAREN"

    public final void mT_LPAREN() throws RecognitionException {

        try {

            int _type = T_LPAREN;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1084:9: ( '(' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1084:11: '('

            {

            match('('); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_LPAREN"

    // $ANTLR start "T_LSQPAREN"

    public final void mT_LSQPAREN() throws RecognitionException {

        try {

            int _type = T_LSQPAREN;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1085:11: ( '[' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1085:13: '['

            {

            match('['); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_LSQPAREN"

    // $ANTLR start "T_MAP"

    public final void mT_MAP() throws RecognitionException {

        try {

            int _type = T_MAP;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1086:7: ( 'map' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1086:9: 'map'

            {

            match("map"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_MAP"

    // $ANTLR start "T_MAPS"

    public final void mT_MAPS() throws RecognitionException {

        try {

            int _type = T_MAPS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1087:8: ( '->' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1087:10: '->'

            {

            match("->"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_MAPS"

    // $ANTLR start "T_METHODS"

    public final void mT_METHODS() throws RecognitionException {

        try {

            int _type = T_METHODS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1089:2: ( 'methods' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1089:4: 'methods'

            {

            match("methods"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_METHODS"

    // $ANTLR start "T_NEW"

    public final void mT_NEW() throws RecognitionException {

        try {

            int _type = T_NEW;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1090:7: ( 'new' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1090:9: 'new'

            {

            match("new"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_NEW"

    // $ANTLR start "T_NIL"

    public final void mT_NIL() throws RecognitionException {

        try {

            int _type = T_NIL;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1091:7: ( 'nil' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1091:9: 'nil'

            {

            match("nil"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_NIL"

    // $ANTLR start "T_NONDET"

    public final void mT_NONDET() throws RecognitionException {

        try {

            int _type = T_NONDET;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1092:9: ( '[]' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1092:11: '[]'

            {

            match("[]"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_NONDET"

    // $ANTLR start "T_OBS"

    public final void mT_OBS() throws RecognitionException {

        try {

            int _type = T_OBS;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1093:7: ( 'obs' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1093:9: 'obs'

            {

            match("obs"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally {

        	// do for sure before leaving

        }

    }

    // $ANTLR end "T_OBS"

    // $ANTLR start "T_OD"

    public final void mT_OD() throws RecognitionException {

        try {

            int _type = T_OD;

            int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1094:6: ( 'od' )

            // C:\\Users\\KrennW\\Documents\\svn\\public\\tug_ist\\trunk\\momut\\uml_ooas\\ooas_compiler\\java\\src\\org\\momut\\ooas\\parser\\ooa.g:1094:8: 'od'

            {

            match("od"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;