// $ANTLR 3.2 Sep 23, 2009 12:02:23 ooa.g 2013-10-10 13:45:32

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


/*
    Ulysses OO-Action System Parser

    Copyright Willibald Krenn 2009

 */


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;
namespace  TUG.Mogentes 
{
public partial class ooaLexer : Lexer {
    public const int T_FLOATNUMBER = 29;
    public const int T_SYSTEM = 6;
    public const int T_ELSE = 87;
    public const int T_LPAREN = 12;
    public const int T_DUNION = 102;
    public const int T_BOOL = 25;
    public const int T_METHODS = 35;
    public const int T_INDS = 105;
    public const int T_OR = 69;
    public const int EOF = -1;
    public const int T_OD = 38;
    public const int T_AND = 75;
    public const int T_OF = 18;
    public const int T_STRINGLITERAL = 93;
    public const int T_SET = 66;
    public const int T_SKIP = 52;
    public const int T_WITH = 57;
    public const int T_DOM = 108;
    public const int T_WS = 111;
    public const int T_VAR = 34;
    public const int T_SUM = 47;
    public const int T_REQUIRES = 45;
    public const int T_DINTER = 101;
    public const int T_AUTOCONS = 33;
    public const int T_HEAD = 104;
    public const int T_END = 43;
    public const int T_TRUE = 90;
    public const int T_LSQPAREN = 15;
    public const int T_MAPS = 96;
    public const int T_PRIMED = 97;
    public const int T_INFTY = 24;
    public const int T_NIL = 92;
    public const int T_IF = 85;
    public const int LINE_COMMENT = 113;
    public const int T_THEN = 86;
    public const int T_FLOAT = 28;
    public const int T_SELF = 55;
    public const int T_TAIL = 107;
    public const int T_DIFF = 48;
    public const int T_MERGE = 110;
    public const int T_FOLDRL = 51;
    public const int T_QUANTITY = 22;
    public const int T_IN = 65;
    public const int T_MUNION = 82;
    public const int T__126 = 126;
    public const int T__125 = 125;
    public const int T_INTER = 74;
    public const int T_SEMICOLON = 7;
    public const int T_FOLDLR = 50;
    public const int T_CARD = 99;
    public const int T_FALSE = 91;
    public const int T_CONT = 44;
    public const int T_SUBSET = 68;
    public const int T_COMMA = 19;
    public const int T_RANGETO = 27;
    public const int T_MINUS = 23;
    public const int T_CONC = 77;
    public const int T_IDIV = 71;
    public const int T_FORALL = 88;
    public const int T_DERIV = 46;
    public const int T_CONSTS = 4;
    public const int T_TYPES = 5;
    public const int T_GREATEREQUAL = 60;
    public const int T__118 = 118;
    public const int T_RNG = 109;
    public const int T__119 = 119;
    public const int T_MOD = 72;
    public const int T__117 = 117;
    public const int T_SEQMOD_MAPOVERRIDE = 83;
    public const int T__124 = 124;
    public const int T__123 = 123;
    public const int T_ELEMS = 103;
    public const int T__122 = 122;
    public const int T__121 = 121;
    public const int T_IMPLIES = 64;
    public const int T__120 = 120;
    public const int T_EXISTS = 89;
    public const int T_POW = 76;
    public const int T_COMMENT = 112;
    public const int T_RPAREN = 13;
    public const int T_PRIO = 10;
    public const int T_RNGRESBY = 80;
    public const int T_ABS = 98;
    public const int T_DIV = 70;
    public const int T_LIST = 14;
    public const int T_CBRL = 31;
    public const int T_DCONC = 100;
    public const int T_ABORT = 53;
    public const int T_CHAR = 30;
    public const int T_STATIC = 39;
    public const int T_POINT = 84;
    public const int T_INT = 26;
    public const int T_CBRR = 32;
    public const int T_PROD = 49;
    public const int T_COLON = 42;
    public const int T_ACTIONS = 36;
    public const int T_LESS = 61;
    public const int T_DIGIT = 114;
    public const int T_BAR = 95;
    public const int T_TO = 21;
    public const int T_NONDET = 11;
    public const int T_DOMRESBY = 78;
    public const int T_DOMRESTO = 79;
    public const int T_EQUAL = 9;
    public const int T_GREATER = 59;
    public const int T_KILL = 54;
    public const int T_RNGRESTO = 81;
    public const int T_RSQPAREN = 17;
    public const int T_NEW = 94;
    public const int T_INTNUMBER = 16;
    public const int T_UNION = 73;
    public const int T_OBS = 40;
    public const int T_BIIMPLIES = 58;
    public const int T_NOTEQUAL = 63;
    public const int T_IDENTIFIER = 8;
    public const int T_DO = 37;
    public const int FLOAT_OR_INT_OR_RANGE = 115;
    public const int T_NOT = 67;
    public const int T_LEN = 106;
    public const int T_ASSIGNMENT = 56;
    public const int T_LETTER = 116;
    public const int T_LESSEQUAL = 62;
    public const int T_MAP = 20;
    public const int T_CTRL = 41;

    // delegates
    // delegators

    public ooaLexer() 
    {
		InitializeCyclicDFAs();
    }
    public ooaLexer(ICharStream input)
		: this(input, null) {
    }
    public ooaLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "ooa.g";} 
    }

    // $ANTLR start "T__117"
    public void mT__117() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__117;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:17:8: ( '|[' )
            // ooa.g:17:10: '|['
            {
            	Match("|["); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__117"

    // $ANTLR start "T__118"
    public void mT__118() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__118;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:18:8: ( ']|' )
            // ooa.g:18:10: ']|'
            {
            	Match("]|"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__118"

    // $ANTLR start "T__119"
    public void mT__119() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__119;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:19:8: ( 'begin' )
            // ooa.g:19:10: 'begin'
            {
            	Match("begin"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__119"

    // $ANTLR start "T__120"
    public void mT__120() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__120;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:20:8: ( '&' )
            // ooa.g:20:10: '&'
            {
            	Match('&'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__120"

    // $ANTLR start "T__121"
    public void mT__121() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__121;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:21:8: ( 'as' )
            // ooa.g:21:10: 'as'
            {
            	Match("as"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__121"

    // $ANTLR start "T__122"
    public void mT__122() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__122;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:22:8: ( 'qval' )
            // ooa.g:22:10: 'qval'
            {
            	Match("qval"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__122"

    // $ANTLR start "T__123"
    public void mT__123() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__123;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:23:8: ( 'steady' )
            // ooa.g:23:10: 'steady'
            {
            	Match("steady"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__123"

    // $ANTLR start "T__124"
    public void mT__124() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__124;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:24:8: ( 'inc' )
            // ooa.g:24:10: 'inc'
            {
            	Match("inc"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__124"

    // $ANTLR start "T__125"
    public void mT__125() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__125;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:25:8: ( 'dec' )
            // ooa.g:25:10: 'dec'
            {
            	Match("dec"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__125"

    // $ANTLR start "T__126"
    public void mT__126() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__126;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:26:8: ( '::' )
            // ooa.g:26:10: '::'
            {
            	Match("::"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__126"

    // $ANTLR start "T_WS"
    public void mT_WS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_WS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:992:8: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
            // ooa.g:992: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 
    	{
        }
    }
    // $ANTLR end "T_WS"

    // $ANTLR start "T_COMMENT"
    public void mT_COMMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_COMMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:996:6: ( '/*' ( . )* '*/' )
            // ooa.g:996:8: '/*' ( . )* '*/'
            {
            	Match("/*"); if (state.failed) return ;

            	// ooa.g:996:13: ( . )*
            	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 :
            			    // ooa.g:996:13: .
            			    {
            			    	MatchAny(); if (state.failed) return ;

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements

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

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

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_COMMENT"

    // $ANTLR start "LINE_COMMENT"
    public void mLINE_COMMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LINE_COMMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1000:6: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
            // ooa.g:1000:8: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
            {
            	Match('#'); if (state.failed) return ;
            	// ooa.g:1000:12: (~ ( '\\n' | '\\r' ) )*
            	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 :
            			    // ooa.g:1000:12: ~ ( '\\n' | '\\r' )
            			    {
            			    	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:
            			    goto loop2;
            	    }
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whining that label 'loop2' has no statements

            	// ooa.g:1000:26: ( '\\r' )?
            	int alt3 = 2;
            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == '\r') )
            	{
            	    alt3 = 1;
            	}
            	switch (alt3) 
            	{
            	    case 1 :
            	        // ooa.g:1000: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 
    	{
        }
    }
    // $ANTLR end "LINE_COMMENT"

    // $ANTLR start "T_PRIMED"
    public void mT_PRIMED() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_PRIMED;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1004:2: ( '\\'' )
            // ooa.g:1004:4: '\\''
            {
            	Match('\''); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_PRIMED"

    // $ANTLR start "T_STRINGLITERAL"
    public void mT_STRINGLITERAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_STRINGLITERAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1007:2: ( '\"' ( ( '\"' '\"' )=> '\"' | ~ '\"' )* '\"' )
            // ooa.g:1007:4: '\"' ( ( '\"' '\"' )=> '\"' | ~ '\"' )* '\"'
            {
            	Match('\"'); if (state.failed) return ;
            	// ooa.g:1008:3: ( ( '\"' '\"' )=> '\"' | ~ '\"' )*
            	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 :
            			    // ooa.g:1009:9: ( '\"' '\"' )=> '\"'
            			    {
            			    	Match('\"'); if (state.failed) return ;

            			    }
            			    break;
            			case 2 :
            			    // ooa.g:1010: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:
            			    goto loop4;
            	    }
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements

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

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_STRINGLITERAL"

    // $ANTLR start "T_ABORT"
    public void mT_ABORT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ABORT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1016:9: ( 'abort' )
            // ooa.g:1016:11: 'abort'
            {
            	Match("abort"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ABORT"

    // $ANTLR start "T_ACTIONS"
    public void mT_ACTIONS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ACTIONS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1018:2: ( 'actions' )
            // ooa.g:1018:4: 'actions'
            {
            	Match("actions"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ACTIONS"

    // $ANTLR start "T_ASSIGNMENT"
    public void mT_ASSIGNMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ASSIGNMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1020:2: ( ':=' )
            // ooa.g:1020:4: ':='
            {
            	Match(":="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ASSIGNMENT"

    // $ANTLR start "T_AUTOCONS"
    public void mT_AUTOCONS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_AUTOCONS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1021:11: ( 'autocons' )
            // ooa.g:1021:13: 'autocons'
            {
            	Match("autocons"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_AUTOCONS"

    // $ANTLR start "T_BAR"
    public void mT_BAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_BAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1022:7: ( '|' )
            // ooa.g:1022:9: '|'
            {
            	Match('|'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_BAR"

    // $ANTLR start "T_BOOL"
    public void mT_BOOL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_BOOL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1023:8: ( 'bool' )
            // ooa.g:1023:10: 'bool'
            {
            	Match("bool"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_BOOL"

    // $ANTLR start "T_CBRL"
    public void mT_CBRL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CBRL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1024:8: ( '{' )
            // ooa.g:1024:10: '{'
            {
            	Match('{'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CBRL"

    // $ANTLR start "T_CBRR"
    public void mT_CBRR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CBRR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1025:8: ( '}' )
            // ooa.g:1025:10: '}'
            {
            	Match('}'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CBRR"

    // $ANTLR start "T_COLON"
    public void mT_COLON() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_COLON;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1026:9: ( ':' )
            // ooa.g:1026:11: ':'
            {
            	Match(':'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_COLON"

    // $ANTLR start "T_COMMA"
    public void mT_COMMA() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_COMMA;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1027:9: ( ',' )
            // ooa.g:1027:11: ','
            {
            	Match(','); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_COMMA"

    // $ANTLR start "T_CONT"
    public void mT_CONT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CONT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1028:8: ( 'qual' )
            // ooa.g:1028:10: 'qual'
            {
            	Match("qual"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CONT"

    // $ANTLR start "T_CHAR"
    public void mT_CHAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CHAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1029:8: ( 'char' )
            // ooa.g:1029:10: 'char'
            {
            	Match("char"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CHAR"

    // $ANTLR start "T_CTRL"
    public void mT_CTRL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CTRL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1030:9: ( 'ctr' )
            // ooa.g:1030:11: 'ctr'
            {
            	Match("ctr"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CTRL"

    // $ANTLR start "T_SYSTEM"
    public void mT_SYSTEM() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SYSTEM;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1032:2: ( 'system' )
            // ooa.g:1032:4: 'system'
            {
            	Match("system"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SYSTEM"

    // $ANTLR start "T_DO"
    public void mT_DO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1033:6: ( 'do' )
            // ooa.g:1033:8: 'do'
            {
            	Match("do"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DO"

    // $ANTLR start "T_ELSE"
    public void mT_ELSE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ELSE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1034:8: ( 'else' )
            // ooa.g:1034:10: 'else'
            {
            	Match("else"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ELSE"

    // $ANTLR start "T_END"
    public void mT_END() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_END;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1035:7: ( 'end' )
            // ooa.g:1035:9: 'end'
            {
            	Match("end"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_END"

    // $ANTLR start "T_EQUAL"
    public void mT_EQUAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_EQUAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1036:9: ( '=' )
            // ooa.g:1036:11: '='
            {
            	Match('='); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_EQUAL"

    // $ANTLR start "T_EXISTS"
    public void mT_EXISTS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_EXISTS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1037:9: ( 'exists' )
            // ooa.g:1037:11: 'exists'
            {
            	Match("exists"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_EXISTS"

    // $ANTLR start "T_FLOAT"
    public void mT_FLOAT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_FLOAT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1038:9: ( 'float' )
            // ooa.g:1038:11: 'float'
            {
            	Match("float"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FLOAT"

    // $ANTLR start "T_FORALL"
    public void mT_FORALL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_FORALL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1039:9: ( 'forall' )
            // ooa.g:1039:11: 'forall'
            {
            	Match("forall"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FORALL"

    // $ANTLR start "T_FALSE"
    public void mT_FALSE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_FALSE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1040:9: ( 'false' )
            // ooa.g:1040:11: 'false'
            {
            	Match("false"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FALSE"

    // $ANTLR start "T_IF"
    public void mT_IF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_IF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1041:6: ( 'if' )
            // ooa.g:1041:8: 'if'
            {
            	Match("if"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_IF"

    // $ANTLR start "T_IN"
    public void mT_IN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_IN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1042:6: ( 'in' )
            // ooa.g:1042:8: 'in'
            {
            	Match("in"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_IN"

    // $ANTLR start "T_INT"
    public void mT_INT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_INT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1043:7: ( 'int' )
            // ooa.g:1043:9: 'int'
            {
            	Match("int"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_INT"

    // $ANTLR start "T_KILL"
    public void mT_KILL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_KILL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1044:8: ( 'kill' )
            // ooa.g:1044:10: 'kill'
            {
            	Match("kill"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_KILL"

    // $ANTLR start "T_LIST"
    public void mT_LIST() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LIST;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1045:8: ( 'list' )
            // ooa.g:1045:10: 'list'
            {
            	Match("list"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LIST"

    // $ANTLR start "T_LPAREN"
    public void mT_LPAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LPAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1046:9: ( '(' )
            // ooa.g:1046:11: '('
            {
            	Match('('); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LPAREN"

    // $ANTLR start "T_LSQPAREN"
    public void mT_LSQPAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LSQPAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1047:11: ( '[' )
            // ooa.g:1047:13: '['
            {
            	Match('['); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LSQPAREN"

    // $ANTLR start "T_MAP"
    public void mT_MAP() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_MAP;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1048:7: ( 'map' )
            // ooa.g:1048:9: 'map'
            {
            	Match("map"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MAP"

    // $ANTLR start "T_MAPS"
    public void mT_MAPS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_MAPS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1049:8: ( '->' )
            // ooa.g:1049:10: '->'
            {
            	Match("->"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MAPS"

    // $ANTLR start "T_METHODS"
    public void mT_METHODS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_METHODS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1051:2: ( 'methods' )
            // ooa.g:1051:4: 'methods'
            {
            	Match("methods"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_METHODS"

    // $ANTLR start "T_NEW"
    public void mT_NEW() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_NEW;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1052:7: ( 'new' )
            // ooa.g:1052:9: 'new'
            {
            	Match("new"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_NEW"

    // $ANTLR start "T_NIL"
    public void mT_NIL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_NIL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1053:7: ( 'nil' )
            // ooa.g:1053:9: 'nil'
            {
            	Match("nil"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_NIL"

    // $ANTLR start "T_NONDET"
    public void mT_NONDET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_NONDET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1054:9: ( '[]' )
            // ooa.g:1054:11: '[]'
            {
            	Match("[]"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_NONDET"

    // $ANTLR start "T_OBS"
    public void mT_OBS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_OBS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1055:7: ( 'obs' )
            // ooa.g:1055:9: 'obs'
            {
            	Match("obs"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_OBS"

    // $ANTLR start "T_OD"
    public void mT_OD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_OD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1056:6: ( 'od' )
            // ooa.g:1056:8: 'od'
            {
            	Match("od"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_OD"

    // $ANTLR start "T_OF"
    public void mT_OF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_OF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1057:6: ( 'of' )
            // ooa.g:1057:8: 'of'
            {
            	Match("of"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_OF"

    // $ANTLR start "T_PRIO"
    public void mT_PRIO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_PRIO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1058:8: ( '//' )
            // ooa.g:1058:10: '//'
            {
            	Match("//"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_PRIO"

    // $ANTLR start "T_REQUIRES"
    public void mT_REQUIRES() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_REQUIRES;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1060:2: ( 'requires' )
            // ooa.g:1060:4: 'requires'
            {
            	Match("requires"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_REQUIRES"

    // $ANTLR start "T_RPAREN"
    public void mT_RPAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_RPAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1061:9: ( ')' )
            // ooa.g:1061:11: ')'
            {
            	Match(')'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RPAREN"

    // $ANTLR start "T_RSQPAREN"
    public void mT_RSQPAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_RSQPAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1062:11: ( ']' )
            // ooa.g:1062:13: ']'
            {
            	Match(']'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RSQPAREN"

    // $ANTLR start "T_QUANTITY"
    public void mT_QUANTITY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_QUANTITY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1064:2: ( 'qspace' )
            // ooa.g:1064:4: 'qspace'
            {
            	Match("qspace"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_QUANTITY"

    // $ANTLR start "T_SELF"
    public void mT_SELF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SELF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1065:8: ( 'self' )
            // ooa.g:1065:10: 'self'
            {
            	Match("self"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SELF"

    // $ANTLR start "T_SET"
    public void mT_SET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1066:8: ( 'set' )
            // ooa.g:1066:10: 'set'
            {
            	Match("set"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SET"

    // $ANTLR start "T_SEMICOLON"
    public void mT_SEMICOLON() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SEMICOLON;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1068:2: ( ';' )
            // ooa.g:1068:4: ';'
            {
            	Match(';'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SEMICOLON"

    // $ANTLR start "T_STATIC"
    public void mT_STATIC() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_STATIC;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1069:9: ( 'static' )
            // ooa.g:1069:11: 'static'
            {
            	Match("static"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_STATIC"

    // $ANTLR start "T_SKIP"
    public void mT_SKIP() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SKIP;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1070:8: ( 'skip' )
            // ooa.g:1070:10: 'skip'
            {
            	Match("skip"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SKIP"

    // $ANTLR start "T_THEN"
    public void mT_THEN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_THEN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1071:8: ( 'then' )
            // ooa.g:1071:10: 'then'
            {
            	Match("then"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_THEN"

    // $ANTLR start "T_TRUE"
    public void mT_TRUE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_TRUE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1072:9: ( 'true' )
            // ooa.g:1072:11: 'true'
            {
            	Match("true"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_TRUE"

    // $ANTLR start "T_TO"
    public void mT_TO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_TO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1073:6: ( 'to' )
            // ooa.g:1073:8: 'to'
            {
            	Match("to"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_TO"

    // $ANTLR start "T_TYPES"
    public void mT_TYPES() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_TYPES;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1074:9: ( 'types' )
            // ooa.g:1074:11: 'types'
            {
            	Match("types"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_TYPES"

    // $ANTLR start "T_VAR"
    public void mT_VAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_VAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1075:7: ( 'var' )
            // ooa.g:1075:9: 'var'
            {
            	Match("var"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_VAR"

    // $ANTLR start "T_WITH"
    public void mT_WITH() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_WITH;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1076:8: ( 'with' )
            // ooa.g:1076:10: 'with'
            {
            	Match("with"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_WITH"

    // $ANTLR start "T_AND"
    public void mT_AND() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_AND;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1082:7: ( 'and' )
            // ooa.g:1082:9: 'and'
            {
            	Match("and"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_AND"

    // $ANTLR start "T_BIIMPLIES"
    public void mT_BIIMPLIES() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_BIIMPLIES;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1084:2: ( '<=>' )
            // ooa.g:1084:4: '<=>'
            {
            	Match("<=>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_BIIMPLIES"

    // $ANTLR start "T_IMPLIES"
    public void mT_IMPLIES() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_IMPLIES;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1086:2: ( '=>' )
            // ooa.g:1086:4: '=>'
            {
            	Match("=>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_IMPLIES"

    // $ANTLR start "T_NOT"
    public void mT_NOT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_NOT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1087:7: ( 'not' )
            // ooa.g:1087:9: 'not'
            {
            	Match("not"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_NOT"

    // $ANTLR start "T_NOTEQUAL"
    public void mT_NOTEQUAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_NOTEQUAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1088:11: ( '<>' )
            // ooa.g:1088:13: '<>'
            {
            	Match("<>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_NOTEQUAL"

    // $ANTLR start "T_OR"
    public void mT_OR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_OR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1089:6: ( 'or' )
            // ooa.g:1089:8: 'or'
            {
            	Match("or"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_OR"

    // $ANTLR start "T_ABS"
    public void mT_ABS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ABS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1092:7: ( 'abs' )
            // ooa.g:1092:9: 'abs'
            {
            	Match("abs"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ABS"

    // $ANTLR start "T_DIV"
    public void mT_DIV() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DIV;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1093:7: ( '/' )
            // ooa.g:1093:9: '/'
            {
            	Match('/'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DIV"

    // $ANTLR start "T_GREATER"
    public void mT_GREATER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_GREATER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1095:2: ( '>' )
            // ooa.g:1095:4: '>'
            {
            	Match('>'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_GREATER"

    // $ANTLR start "T_GREATEREQUAL"
    public void mT_GREATEREQUAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_GREATEREQUAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1097:2: ( '>=' )
            // ooa.g:1097:4: '>='
            {
            	Match(">="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_GREATEREQUAL"

    // $ANTLR start "T_IDIV"
    public void mT_IDIV() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_IDIV;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1098:8: ( 'div' )
            // ooa.g:1098:10: 'div'
            {
            	Match("div"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_IDIV"

    // $ANTLR start "T_LESS"
    public void mT_LESS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LESS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1099:8: ( '<' )
            // ooa.g:1099:10: '<'
            {
            	Match('<'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LESS"

    // $ANTLR start "T_LESSEQUAL"
    public void mT_LESSEQUAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LESSEQUAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1101:2: ( '<=' )
            // ooa.g:1101:4: '<='
            {
            	Match("<="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LESSEQUAL"

    // $ANTLR start "T_MOD"
    public void mT_MOD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_MOD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1102:7: ( 'mod' )
            // ooa.g:1102:9: 'mod'
            {
            	Match("mod"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MOD"

    // $ANTLR start "T_POW"
    public void mT_POW() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_POW;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1103:7: ( '**' )
            // ooa.g:1103:9: '**'
            {
            	Match("**"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_POW"

    // $ANTLR start "T_PROD"
    public void mT_PROD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_PROD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1104:8: ( '*' )
            // ooa.g:1104:10: '*'
            {
            	Match('*'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_PROD"

    // $ANTLR start "T_DERIV"
    public void mT_DERIV() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DERIV;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1105:9: ( 'dt' )
            // ooa.g:1105:11: 'dt'
            {
            	Match("dt"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DERIV"

    // $ANTLR start "T_CARD"
    public void mT_CARD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CARD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1108:8: ( 'card' )
            // ooa.g:1108:10: 'card'
            {
            	Match("card"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CARD"

    // $ANTLR start "T_CONC"
    public void mT_CONC() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CONC;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1109:8: ( '^' )
            // ooa.g:1109:10: '^'
            {
            	Match('^'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CONC"

    // $ANTLR start "T_DCONC"
    public void mT_DCONC() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DCONC;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1110:9: ( 'conc' )
            // ooa.g:1110:11: 'conc'
            {
            	Match("conc"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DCONC"

    // $ANTLR start "T_DIFF"
    public void mT_DIFF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DIFF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1111:8: ( '\\\\' )
            // ooa.g:1111:10: '\\\\'
            {
            	Match('\\'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DIFF"

    // $ANTLR start "T_DINTER"
    public void mT_DINTER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DINTER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1112:9: ( 'dinter' )
            // ooa.g:1112:11: 'dinter'
            {
            	Match("dinter"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DINTER"

    // $ANTLR start "T_DUNION"
    public void mT_DUNION() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DUNION;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1113:9: ( 'dunion' )
            // ooa.g:1113:11: 'dunion'
            {
            	Match("dunion"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DUNION"

    // $ANTLR start "T_ELEMS"
    public void mT_ELEMS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_ELEMS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1114:9: ( 'elems' )
            // ooa.g:1114:11: 'elems'
            {
            	Match("elems"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_ELEMS"

    // $ANTLR start "T_HEAD"
    public void mT_HEAD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_HEAD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1115:8: ( 'hd' )
            // ooa.g:1115:10: 'hd'
            {
            	Match("hd"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_HEAD"

    // $ANTLR start "T_INDS"
    public void mT_INDS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_INDS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1116:8: ( 'inds' )
            // ooa.g:1116:10: 'inds'
            {
            	Match("inds"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_INDS"

    // $ANTLR start "T_INTER"
    public void mT_INTER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_INTER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1117:9: ( 'inter' )
            // ooa.g:1117:11: 'inter'
            {
            	Match("inter"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_INTER"

    // $ANTLR start "T_LEN"
    public void mT_LEN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_LEN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1118:7: ( 'len' )
            // ooa.g:1118:9: 'len'
            {
            	Match("len"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LEN"

    // $ANTLR start "T_SEQMOD_MAPOVERRIDE"
    public void mT_SEQMOD_MAPOVERRIDE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SEQMOD_MAPOVERRIDE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1120:2: ( '++' )
            // ooa.g:1120:4: '++'
            {
            	Match("++"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SEQMOD_MAPOVERRIDE"

    // $ANTLR start "T_SUBSET"
    public void mT_SUBSET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_SUBSET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1121:9: ( 'subset' )
            // ooa.g:1121:11: 'subset'
            {
            	Match("subset"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SUBSET"

    // $ANTLR start "T_TAIL"
    public void mT_TAIL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_TAIL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1122:8: ( 'tl' )
            // ooa.g:1122:10: 'tl'
            {
            	Match("tl"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_TAIL"

    // $ANTLR start "T_UNION"
    public void mT_UNION() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_UNION;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1123:9: ( 'union' )
            // ooa.g:1123:11: 'union'
            {
            	Match("union"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_UNION"

    // $ANTLR start "T_FOLDLR"
    public void mT_FOLDLR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_FOLDLR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1125:2: ( ':>:' )
            // ooa.g:1125:4: ':>:'
            {
            	Match(":>:"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FOLDLR"

    // $ANTLR start "T_FOLDRL"
    public void mT_FOLDRL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_FOLDRL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1127:2: ( ':<:' )
            // ooa.g:1127:4: ':<:'
            {
            	Match(":<:"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FOLDRL"

    // $ANTLR start "T_DOM"
    public void mT_DOM() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DOM;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1131:7: ( 'dom' )
            // ooa.g:1131:9: 'dom'
            {
            	Match("dom"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DOM"

    // $ANTLR start "T_DOMRESBY"
    public void mT_DOMRESBY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DOMRESBY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1133:2: ( '<-:' )
            // ooa.g:1133:4: '<-:'
            {
            	Match("<-:"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DOMRESBY"

    // $ANTLR start "T_DOMRESTO"
    public void mT_DOMRESTO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_DOMRESTO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1135:2: ( '<:' )
            // ooa.g:1135:4: '<:'
            {
            	Match("<:"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DOMRESTO"

    // $ANTLR start "T_RNG"
    public void mT_RNG() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_RNG;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1136:7: ( 'rng' )
            // ooa.g:1136:9: 'rng'
            {
            	Match("rng"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RNG"

    // $ANTLR start "T_RNGRESBY"
    public void mT_RNGRESBY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_RNGRESBY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1138:2: ( ':->' )
            // ooa.g:1138:4: ':->'
            {
            	Match(":->"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RNGRESBY"

    // $ANTLR start "T_RNGRESTO"
    public void mT_RNGRESTO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_RNGRESTO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1140:2: ( ':>' )
            // ooa.g:1140:4: ':>'
            {
            	Match(":>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RNGRESTO"

    // $ANTLR start "T_MERGE"
    public void mT_MERGE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_MERGE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1141:9: ( 'merge' )
            // ooa.g:1141:11: 'merge'
            {
            	Match("merge"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MERGE"

    // $ANTLR start "T_MUNION"
    public void mT_MUNION() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_MUNION;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1142:9: ( 'munion' )
            // ooa.g:1142:11: 'munion'
            {
            	Match("munion"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MUNION"

    // $ANTLR start "T_CONSTS"
    public void mT_CONSTS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_CONSTS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1144:9: ( 'consts' )
            // ooa.g:1144:11: 'consts'
            {
            	Match("consts"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_CONSTS"

    // $ANTLR start "T_INFTY"
    public void mT_INFTY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_INFTY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1148:9: ( ( T_MINUS | T_SUM )? 'inf' )
            // ooa.g:1148:11: ( T_MINUS | T_SUM )? 'inf'
            {
            	// ooa.g:1148:11: ( T_MINUS | T_SUM )?
            	int alt5 = 2;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == '+' || LA5_0 == '-') )
            	{
            	    alt5 = 1;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // ooa.g:
            	        {
            	        	if ( input.LA(1) == '+' || 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;}


            	        }
            	        break;

            	}

            	Match("inf"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_INFTY"

    // $ANTLR start "T_INTNUMBER"
    public void mT_INTNUMBER() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1155:2: ()
            // ooa.g:1155:4: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_INTNUMBER"

    // $ANTLR start "T_FLOATNUMBER"
    public void mT_FLOATNUMBER() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1157:2: ()
            // ooa.g:1157:4: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_FLOATNUMBER"

    // $ANTLR start "T_RANGETO"
    public void mT_RANGETO() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1159:2: ()
            // ooa.g:1159:4: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_RANGETO"

    // $ANTLR start "FLOAT_OR_INT_OR_RANGE"
    public void mFLOAT_OR_INT_OR_RANGE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = FLOAT_OR_INT_OR_RANGE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1162:2: ( ( T_MINUS | T_SUM )? ( T_DIGIT )+ ( ( T_POINT T_POINT )=> | ( T_POINT T_DIGIT )=> T_POINT ( T_DIGIT )+ ( ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+ )? | ) | T_POINT ( T_POINT | ) | T_MINUS | T_SUM )
            int alt14 = 4;
            switch ( input.LA(1) ) 
            {
            case '-':
            	{
                int LA14_1 = input.LA(2);

                if ( ((LA14_1 >= '0' && LA14_1 <= '9')) )
                {
                    alt14 = 1;
                }
                else 
                {
                    alt14 = 3;}
                }
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            	{
                alt14 = 1;
                }
                break;
            case '.':
            	{
                alt14 = 2;
                }
                break;
            case '+':
            	{
                int LA14_4 = input.LA(2);

                if ( ((LA14_4 >= '0' && LA14_4 <= '9')) )
                {
                    alt14 = 1;
                }
                else 
                {
                    alt14 = 4;}
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d14s0 =
            	        new NoViableAltException("", 14, 0, input);

            	    throw nvae_d14s0;
            }

            switch (alt14) 
            {
                case 1 :
                    // ooa.g:1162:5: ( T_MINUS | T_SUM )? ( T_DIGIT )+ ( ( T_POINT T_POINT )=> | ( T_POINT T_DIGIT )=> T_POINT ( T_DIGIT )+ ( ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+ )? | )
                    {
                    	// ooa.g:1162:5: ( T_MINUS | T_SUM )?
                    	int alt6 = 2;
                    	int LA6_0 = input.LA(1);

                    	if ( (LA6_0 == '+' || LA6_0 == '-') )
                    	{
                    	    alt6 = 1;
                    	}
                    	switch (alt6) 
                    	{
                    	    case 1 :
                    	        // ooa.g:
                    	        {
                    	        	if ( input.LA(1) == '+' || 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;}


                    	        }
                    	        break;

                    	}

                    	// ooa.g:1162:22: ( T_DIGIT )+
                    	int cnt7 = 0;
                    	do 
                    	{
                    	    int alt7 = 2;
                    	    int LA7_0 = input.LA(1);

                    	    if ( ((LA7_0 >= '0' && LA7_0 <= '9')) )
                    	    {
                    	        alt7 = 1;
                    	    }


                    	    switch (alt7) 
                    		{
                    			case 1 :
                    			    // ooa.g:1162:22: T_DIGIT
                    			    {
                    			    	mT_DIGIT(); if (state.failed) return ;

                    			    }
                    			    break;

                    			default:
                    			    if ( cnt7 >= 1 ) goto loop7;
                    			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    		            EarlyExitException eee7 =
                    		                new EarlyExitException(7, input);
                    		            throw eee7;
                    	    }
                    	    cnt7++;
                    	} while (true);

                    	loop7:
                    		;	// Stops C# compiler whining that label 'loop7' has no statements

                    	// ooa.g:1163:3: ( ( T_POINT T_POINT )=> | ( T_POINT T_DIGIT )=> T_POINT ( T_DIGIT )+ ( ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+ )? | )
                    	int alt12 = 3;
                    	int LA12_0 = input.LA(1);

                    	if ( (LA12_0 == '.') && (synpred3_ooa()) )
                    	{
                    	    alt12 = 2;
                    	}
                    	else if ( (synpred2_ooa()) )
                    	{
                    	    alt12 = 1;
                    	}
                    	else if ( (true) )
                    	{
                    	    alt12 = 3;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    	    NoViableAltException nvae_d12s0 =
                    	        new NoViableAltException("", 12, 0, input);

                    	    throw nvae_d12s0;
                    	}
                    	switch (alt12) 
                    	{
                    	    case 1 :
                    	        // ooa.g:1164:5: ( T_POINT T_POINT )=>
                    	        {
                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  _type=T_INTNUMBER;
                    	        	}

                    	        }
                    	        break;
                    	    case 2 :
                    	        // ooa.g:1165:6: ( T_POINT T_DIGIT )=> T_POINT ( T_DIGIT )+ ( ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+ )?
                    	        {
                    	        	mT_POINT(); if (state.failed) return ;
                    	        	// ooa.g:1165:35: ( T_DIGIT )+
                    	        	int cnt8 = 0;
                    	        	do 
                    	        	{
                    	        	    int alt8 = 2;
                    	        	    int LA8_0 = input.LA(1);

                    	        	    if ( ((LA8_0 >= '0' && LA8_0 <= '9')) )
                    	        	    {
                    	        	        alt8 = 1;
                    	        	    }


                    	        	    switch (alt8) 
                    	        		{
                    	        			case 1 :
                    	        			    // ooa.g:1165:35: T_DIGIT
                    	        			    {
                    	        			    	mT_DIGIT(); if (state.failed) return ;

                    	        			    }
                    	        			    break;

                    	        			default:
                    	        			    if ( cnt8 >= 1 ) goto loop8;
                    	        			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    	        		            EarlyExitException eee8 =
                    	        		                new EarlyExitException(8, input);
                    	        		            throw eee8;
                    	        	    }
                    	        	    cnt8++;
                    	        	} while (true);

                    	        	loop8:
                    	        		;	// Stops C# compiler whining that label 'loop8' has no statements

                    	        	// ooa.g:1165:44: ( ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+ )?
                    	        	int alt11 = 2;
                    	        	int LA11_0 = input.LA(1);

                    	        	if ( (LA11_0 == 'E' || LA11_0 == 'e') )
                    	        	{
                    	        	    alt11 = 1;
                    	        	}
                    	        	switch (alt11) 
                    	        	{
                    	        	    case 1 :
                    	        	        // ooa.g:1165:45: ( 'e' | 'E' ) ( T_MINUS | T_SUM )? ( T_DIGIT )+
                    	        	        {
                    	        	        	if ( input.LA(1) == 'E' || input.LA(1) == 'e' ) 
                    	        	        	{
                    	        	        	    input.Consume();
                    	        	        	state.failed = false;
                    	        	        	}
                    	        	        	else 
                    	        	        	{
                    	        	        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    	        	        	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        	        	    Recover(mse);
                    	        	        	    throw mse;}

                    	        	        	// ooa.g:1165:55: ( T_MINUS | T_SUM )?
                    	        	        	int alt9 = 2;
                    	        	        	int LA9_0 = input.LA(1);

                    	        	        	if ( (LA9_0 == '+' || LA9_0 == '-') )
                    	        	        	{
                    	        	        	    alt9 = 1;
                    	        	        	}
                    	        	        	switch (alt9) 
                    	        	        	{
                    	        	        	    case 1 :
                    	        	        	        // ooa.g:
                    	        	        	        {
                    	        	        	        	if ( input.LA(1) == '+' || 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;}


                    	        	        	        }
                    	        	        	        break;

                    	        	        	}

                    	        	        	// ooa.g:1165:72: ( T_DIGIT )+
                    	        	        	int cnt10 = 0;
                    	        	        	do 
                    	        	        	{
                    	        	        	    int alt10 = 2;
                    	        	        	    int LA10_0 = input.LA(1);

                    	        	        	    if ( ((LA10_0 >= '0' && LA10_0 <= '9')) )
                    	        	        	    {
                    	        	        	        alt10 = 1;
                    	        	        	    }


                    	        	        	    switch (alt10) 
                    	        	        		{
                    	        	        			case 1 :
                    	        	        			    // ooa.g:1165:72: T_DIGIT
                    	        	        			    {
                    	        	        			    	mT_DIGIT(); if (state.failed) return ;

                    	        	        			    }
                    	        	        			    break;

                    	        	        			default:
                    	        	        			    if ( cnt10 >= 1 ) goto loop10;
                    	        	        			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    	        	        		            EarlyExitException eee10 =
                    	        	        		                new EarlyExitException(10, input);
                    	        	        		            throw eee10;
                    	        	        	    }
                    	        	        	    cnt10++;
                    	        	        	} while (true);

                    	        	        	loop10:
                    	        	        		;	// Stops C# compiler whining that label 'loop10' has no statements


                    	        	        }
                    	        	        break;

                    	        	}

                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  _type=T_FLOATNUMBER;
                    	        	}

                    	        }
                    	        break;
                    	    case 3 :
                    	        // ooa.g:1166:6: 
                    	        {
                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  _type=T_INTNUMBER;
                    	        	}

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // ooa.g:1168:4: T_POINT ( T_POINT | )
                    {
                    	mT_POINT(); if (state.failed) return ;
                    	// ooa.g:1169:3: ( T_POINT | )
                    	int alt13 = 2;
                    	int LA13_0 = input.LA(1);

                    	if ( (LA13_0 == '.') )
                    	{
                    	    alt13 = 1;
                    	}
                    	else 
                    	{
                    	    alt13 = 2;}
                    	switch (alt13) 
                    	{
                    	    case 1 :
                    	        // ooa.g:1170:5: T_POINT
                    	        {
                    	        	mT_POINT(); if (state.failed) return ;
                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  _type=T_RANGETO;
                    	        	}

                    	        }
                    	        break;
                    	    case 2 :
                    	        // ooa.g:1171:13: 
                    	        {
                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  _type=T_POINT;
                    	        	}

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 3 :
                    // ooa.g:1173:4: T_MINUS
                    {
                    	mT_MINUS(); if (state.failed) return ;
                    	if ( (state.backtracking==0) )
                    	{
                    	  _type=T_MINUS;
                    	}

                    }
                    break;
                case 4 :
                    // ooa.g:1174:4: T_SUM
                    {
                    	mT_SUM(); if (state.failed) return ;
                    	if ( (state.backtracking==0) )
                    	{
                    	  _type=T_SUM;
                    	}

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "FLOAT_OR_INT_OR_RANGE"

    // $ANTLR start "T_MINUS"
    public void mT_MINUS() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1179:17: ( '-' )
            // ooa.g:1179:19: '-'
            {
            	Match('-'); if (state.failed) return ;

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_MINUS"

    // $ANTLR start "T_SUM"
    public void mT_SUM() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1180:16: ( '+' )
            // ooa.g:1180:18: '+'
            {
            	Match('+'); if (state.failed) return ;

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_SUM"

    // $ANTLR start "T_POINT"
    public void mT_POINT() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1181:17: ( '.' )
            // ooa.g:1181:19: '.'
            {
            	Match('.'); if (state.failed) return ;

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_POINT"

    // $ANTLR start "T_IDENTIFIER"
    public void mT_IDENTIFIER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T_IDENTIFIER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // ooa.g:1187:2: ( T_LETTER ( T_LETTER | T_DIGIT )* )
            // ooa.g:1187:4: T_LETTER ( T_LETTER | T_DIGIT )*
            {
            	mT_LETTER(); if (state.failed) return ;
            	// ooa.g:1187:13: ( T_LETTER | T_DIGIT )*
            	do 
            	{
            	    int alt15 = 2;
            	    int LA15_0 = input.LA(1);

            	    if ( (LA15_0 == '$' || (LA15_0 >= '0' && LA15_0 <= '9') || (LA15_0 >= 'A' && LA15_0 <= 'Z') || LA15_0 == '_' || (LA15_0 >= 'a' && LA15_0 <= 'z')) )
            	    {
            	        alt15 = 1;
            	    }


            	    switch (alt15) 
            		{
            			case 1 :
            			    // ooa.g:
            			    {
            			    	if ( input.LA(1) == '$' || (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    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:
            			    goto loop15;
            	    }
            	} while (true);

            	loop15:
            		;	// Stops C# compiler whining that label 'loop15' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_IDENTIFIER"

    // $ANTLR start "T_LETTER"
    public void mT_LETTER() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1195:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' )
            // ooa.g:
            {
            	if ( input.LA(1) == '$' || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();
            	state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_LETTER"

    // $ANTLR start "T_DIGIT"
    public void mT_DIGIT() // throws RecognitionException [2]
    {
    		try
    		{
            // ooa.g:1202:8: ( '0' .. '9' )
            // ooa.g:1202:10: '0' .. '9'
            {
            	MatchRange('0','9'); if (state.failed) return ;

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "T_DIGIT"

    override public void mTokens() // throws RecognitionException 
    {
        // ooa.g:1:8: ( T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | T__123 | T__124 | T__125 | T__126 | T_WS | T_COMMENT | LINE_COMMENT | T_PRIMED | T_STRINGLITERAL | T_ABORT | T_ACTIONS | T_ASSIGNMENT | T_AUTOCONS | T_BAR | T_BOOL | T_CBRL | T_CBRR | T_COLON | T_COMMA | T_CONT | T_CHAR | T_CTRL | T_SYSTEM | T_DO | T_ELSE | T_END | T_EQUAL | T_EXISTS | T_FLOAT | T_FORALL | T_FALSE | T_IF | T_IN | T_INT | T_KILL | T_LIST | T_LPAREN | T_LSQPAREN | T_MAP | T_MAPS | T_METHODS | T_NEW | T_NIL | T_NONDET | T_OBS | T_OD | T_OF | T_PRIO | T_REQUIRES | T_RPAREN | T_RSQPAREN | T_QUANTITY | T_SELF | T_SET | T_SEMICOLON | T_STATIC | T_SKIP | T_THEN | T_TRUE | T_TO | T_TYPES | T_VAR | T_WITH | T_AND | T_BIIMPLIES | T_IMPLIES | T_NOT | T_NOTEQUAL | T_OR | T_ABS | T_DIV | T_GREATER | T_GREATEREQUAL | T_IDIV | T_LESS | T_LESSEQUAL | T_MOD | T_POW | T_PROD | T_DERIV | T_CARD | T_CONC | T_DCONC | T_DIFF | T_DINTER | T_DUNION | T_ELEMS | T_HEAD | T_INDS | T_INTER | T_LEN | T_SEQMOD_MAPOVERRIDE | T_SUBSET | T_TAIL | T_UNION | T_FOLDLR | T_FOLDRL | T_DOM | T_DOMRESBY | T_DOMRESTO | T_RNG | T_RNGRESBY | T_RNGRESTO | T_MERGE | T_MUNION | T_CONSTS | T_INFTY | FLOAT_OR_INT_OR_RANGE | T_IDENTIFIER )
        int alt16 = 115;
        alt16 = dfa16.Predict(input);
        switch (alt16) 
        {
            case 1 :
                // ooa.g:1:10: T__117
                {
                	mT__117(); if (state.failed) return ;

                }
                break;
            case 2 :
                // ooa.g:1:17: T__118
                {
                	mT__118(); if (state.failed) return ;

                }
                break;
            case 3 :
                // ooa.g:1:24: T__119
                {
                	mT__119(); if (state.failed) return ;

                }
                break;
            case 4 :
                // ooa.g:1:31: T__120
                {
                	mT__120(); if (state.failed) return ;

                }
                break;
            case 5 :
                // ooa.g:1:38: T__121
                {
                	mT__121(); if (state.failed) return ;

                }
                break;
            case 6 :
                // ooa.g:1:45: T__122
                {
                	mT__122(); if (state.failed) return ;

                }
                break;
            case 7 :
                // ooa.g:1:52: T__123
                {
                	mT__123(); if (state.failed) return ;

                }
                break;
            case 8 :
                // ooa.g:1:59: T__124
                {
                	mT__124(); if (state.failed) return ;

                }
                break;
            case 9 :
                // ooa.g:1:66: T__125
                {
                	mT__125(); if (state.failed) return ;

                }
                break;
            case 10 :
                // ooa.g:1:73: T__126
                {
                	mT__126(); if (state.failed) return ;

                }
                break;
            case 11 :
                // ooa.g:1:80: T_WS
                {
                	mT_WS(); if (state.failed) return ;

                }
                break;
            case 12 :
                // ooa.g:1:85: T_COMMENT
                {
                	mT_COMMENT(); if (state.failed) return ;

                }
                break;
            case 13 :
                // ooa.g:1:95: LINE_COMMENT
                {
                	mLINE_COMMENT(); if (state.failed) return ;

                }
                break;
            case 14 :
                // ooa.g:1:108: T_PRIMED
                {
                	mT_PRIMED(); if (state.failed) return ;

                }
                break;
            case 15 :
                // ooa.g:1:117: T_STRINGLITERAL
                {
                	mT_STRINGLITERAL(); if (state.failed) return ;

                }
                break;
            case 16 :
                // ooa.g:1:133: T_ABORT
                {
                	mT_ABORT(); if (state.failed) return ;

                }
                break;
            case 17 :
                // ooa.g:1:141: T_ACTIONS
                {
                	mT_ACTIONS(); if (state.failed) return ;

                }
                break;
            case 18 :
                // ooa.g:1:151: T_ASSIGNMENT
                {
                	mT_ASSIGNMENT(); if (state.failed) return ;

                }
                break;
            case 19 :
                // ooa.g:1:164: T_AUTOCONS
                {
                	mT_AUTOCONS(); if (state.failed) return ;

                }
                break;
            case 20 :
                // ooa.g:1:175: T_BAR
                {
                	mT_BAR(); if (state.failed) return ;

                }
                break;
            case 21 :
                // ooa.g:1:181: T_BOOL
                {
                	mT_BOOL(); if (state.failed) return ;

                }
                break;
            case 22 :
                // ooa.g:1:188: T_CBRL
                {
                	mT_CBRL(); if (state.failed) return ;

                }
                break;
            case 23 :
                // ooa.g:1:195: T_CBRR
                {
                	mT_CBRR(); if (state.failed) return ;

                }
                break;
            case 24 :
                // ooa.g:1:202: T_COLON
                {
                	mT_COLON(); if (state.failed) return ;

                }
                break;
            case 25 :
                // ooa.g:1:210: T_COMMA
                {
                	mT_COMMA(); if (state.failed) return ;

                }
                break;
            case 26 :
                // ooa.g:1:218: T_CONT
                {
                	mT_CONT(); if (state.failed) return ;

                }
                break;
            case 27 :
                // ooa.g:1:225: T_CHAR
                {
                	mT_CHAR(); if (state.failed) return ;

                }
                break;
            case 28 :
                // ooa.g:1:232: T_CTRL
                {
                	mT_CTRL(); if (state.failed) return ;

                }
                break;
            case 29 :
                // ooa.g:1:239: T_SYSTEM
                {
                	mT_SYSTEM(); if (state.failed) return ;

                }
                break;
            case 30 :
                // ooa.g:1:248: T_DO
                {
                	mT_DO(); if (state.failed) return ;

                }
                break;
            case 31 :
                // ooa.g:1:253: T_ELSE
                {
                	mT_ELSE(); if (state.failed) return ;

                }
                break;
            case 32 :
                // ooa.g:1:260: T_END
                {
                	mT_END(); if (state.failed) return ;

                }
                break;
            case 33 :
                // ooa.g:1:266: T_EQUAL
                {
                	mT_EQUAL(); if (state.failed) return ;

                }
                break;
            case 34 :
                // ooa.g:1:274: T_EXISTS
                {
                	mT_EXISTS(); if (state.failed) return ;

                }
                break;
            case 35 :
                // ooa.g:1:283: T_FLOAT
                {
                	mT_FLOAT(); if (state.failed) return ;

                }
                break;
            case 36 :
                // ooa.g:1:291: T_FORALL
                {
                	mT_FORALL(); if (state.failed) return ;

                }
                break;
            case 37 :
                // ooa.g:1:300: T_FALSE
                {
                	mT_FALSE(); if (state.failed) return ;

                }
                break;
            case 38 :
                // ooa.g:1:308: T_IF
                {
                	mT_IF(); if (state.failed) return ;

                }
                break;
            case 39 :
                // ooa.g:1:313: T_IN
                {
                	mT_IN(); if (state.failed) return ;

                }
                break;
            case 40 :
                // ooa.g:1:318: T_INT
                {
                	mT_INT(); if (state.failed) return ;

                }
                break;
            case 41 :
                // ooa.g:1:324: T_KILL
                {
                	mT_KILL(); if (state.failed) return ;

                }
                break;
            case 42 :
                // ooa.g:1:331: T_LIST
                {
                	mT_LIST(); if (state.failed) return ;

                }
                break;
            case 43 :
                // ooa.g:1:338: T_LPAREN
                {
                	mT_LPAREN(); if (state.failed) return ;

                }
                break;
            case 44 :
                // ooa.g:1:347: T_LSQPAREN
                {
                	mT_LSQPAREN(); if (state.failed) return ;

                }
                break;
            case 45 :
                // ooa.g:1:358: T_MAP
                {
                	mT_MAP(); if (state.failed) return ;

                }
                break;
            case 46 :
                // ooa.g:1:364: T_MAPS
                {
                	mT_MAPS(); if (state.failed) return ;

                }
                break;
            case 47 :
                // ooa.g:1:371: T_METHODS
                {
                	mT_METHODS(); if (state.failed) return ;

                }
                break;
            case 48 :
                // ooa.g:1:381: T_NEW
                {
                	mT_NEW(); if (state.failed) return ;

                }
                break;
            case 49 :
                // ooa.g:1:387: T_NIL
                {
                	mT_NIL(); if (state.failed) return ;

                }
                break;
            case 50 :
                // ooa.g:1:393: T_NONDET
                {
                	mT_NONDET(); if (state.failed) return ;

                }
                break;
            case 51 :
                // ooa.g:1:402: T_OBS
                {
                	mT_OBS(); if (state.failed) return ;

                }
                break;
            case 52 :
                // ooa.g:1:408: T_OD
                {
                	mT_OD(); if (state.failed) return ;

                }
                break;
            case 53 :
                // ooa.g:1:413: T_OF
                {
                	mT_OF(); if (state.failed) return ;

                }
                break;
            case 54 :
                // ooa.g:1:418: T_PRIO
                {
                	mT_PRIO(); if (state.failed) return ;

                }
                break;
            case 55 :
                // ooa.g:1:425: T_REQUIRES
                {
                	mT_REQUIRES(); if (state.failed) return ;

                }
                break;
            case 56 :
                // ooa.g:1:436: T_RPAREN
                {
                	mT_RPAREN(); if (state.failed) return ;

                }
                break;
            case 57 :
                // ooa.g:1:445: T_RSQPAREN
                {
                	mT_RSQPAREN(); if (state.failed) return ;

                }
                break;
            case 58 :
                // ooa.g:1:456: T_QUANTITY
                {
                	mT_QUANTITY(); if (state.failed) return ;

                }
                break;
            case 59 :
                // ooa.g:1:467: T_SELF
                {
                	mT_SELF(); if (state.failed) return ;

                }
                break;
            case 60 :
                // ooa.g:1:474: T_SET
                {
                	mT_SET(); if (state.failed) return ;

                }
                break;
            case 61 :
                // ooa.g:1:480: T_SEMICOLON
                {
                	mT_SEMICOLON(); if (state.failed) return ;

                }
                break;
            case 62 :
                // ooa.g:1:492: T_STATIC
                {
                	mT_STATIC(); if (state.failed) return ;

                }
                break;
            case 63 :
                // ooa.g:1:501: T_SKIP
                {
                	mT_SKIP(); if (state.failed) return ;

                }
                break;
            case 64 :
                // ooa.g:1:508: T_THEN
                {
                	mT_THEN(); if (state.failed) return ;

                }
                break;
            case 65 :
                // ooa.g:1:515: T_TRUE
                {
                	mT_TRUE(); if (state.failed) return ;

                }
                break;
            case 66 :
                // ooa.g:1:522: T_TO
                {
                	mT_TO(); if (state.failed) return ;

                }
                break;
            case 67 :
                // ooa.g:1:527: T_TYPES
                {
                	mT_TYPES(); if (state.failed) return ;

                }
                break;
            case 68 :
                // ooa.g:1:535: T_VAR
                {
                	mT_VAR(); if (state.failed) return ;

                }
                break;
            case 69 :
                // ooa.g:1:541: T_WITH
                {
                	mT_WITH(); if (state.failed) return ;

                }
                break;
            case 70 :
                // ooa.g:1:548: T_AND
                {
                	mT_AND(); if (state.failed) return ;

                }
                break;
            case 71 :
                // ooa.g:1:554: T_BIIMPLIES
                {
                	mT_BIIMPLIES(); if (state.failed) return ;

                }
                break;
            case 72 :
                // ooa.g:1:566: T_IMPLIES
                {
                	mT_IMPLIES(); if (state.failed) return ;

                }
                break;
            case 73 :
                // ooa.g:1:576: T_NOT
                {
                	mT_NOT(); if (state.failed) return ;

                }
                break;
            case 74 :
                // ooa.g:1:582: T_NOTEQUAL
                {
                	mT_NOTEQUAL(); if (state.failed) return ;

                }
                break;
            case 75 :
                // ooa.g:1:593: T_OR
                {
                	mT_OR(); if (state.failed) return ;

                }
                break;
            case 76 :
                // ooa.g:1:598: T_ABS
                {
                	mT_ABS(); if (state.failed) return ;

                }
                break;
            case 77 :
                // ooa.g:1:604: T_DIV
                {
                	mT_DIV(); if (state.failed) return ;

                }
                break;
            case 78 :
                // ooa.g:1:610: T_GREATER
                {
                	mT_GREATER(); if (state.failed) return ;

                }
                break;
            case 79 :
                // ooa.g:1:620: T_GREATEREQUAL
                {
                	mT_GREATEREQUAL(); if (state.failed) return ;

                }
                break;
            case 80 :
                // ooa.g:1:635: T_IDIV
                {
                	mT_IDIV(); if (state.failed) return ;

                }
                break;
            case 81 :
                // ooa.g:1:642: T_LESS
                {
                	mT_LESS(); if (state.failed) return ;

                }
                break;
            case 82 :
                // ooa.g:1:649: T_LESSEQUAL
                {
                	mT_LESSEQUAL(); if (state.failed) return ;

                }
                break;
            case 83 :
                // ooa.g:1:661: T_MOD
                {
                	mT_MOD(); if (state.failed) return ;

                }
                break;
            case 84 :
                // ooa.g:1:667: T_POW
                {
                	mT_POW(); if (state.failed) return ;

                }
                break;
            case 85 :
                // ooa.g:1:673: T_PROD
                {
                	mT_PROD(); if (state.failed) return ;

                }
                break;
            case 86 :
                // ooa.g:1:680: T_DERIV
                {
                	mT_DERIV(); if (state.failed) return ;

                }
                break;
            case 87 :
                // ooa.g:1:688: T_CARD
                {
                	mT_CARD(); if (state.failed) return ;

                }
                break;
            case 88 :
                // ooa.g:1:695: T_CONC
                {
                	mT_CONC(); if (state.failed) return ;

                }
                break;
            case 89 :
                // ooa.g:1:702: T_DCONC
                {
                	mT_DCONC(); if (state.failed) return ;

                }
                break;
            case 90 :
                // ooa.g:1:710: T_DIFF
                {
                	mT_DIFF(); if (state.failed) return ;

                }
                break;
            case 91 :
                // ooa.g:1:717: T_DINTER
                {
                	mT_DINTER(); if (state.failed) return ;

                }
                break;
            case 92 :
                // ooa.g:1:726: T_DUNION
                {
                	mT_DUNION(); if (state.failed) return ;

                }
                break;
            case 93 :
                // ooa.g:1:735: T_ELEMS
                {
                	mT_ELEMS(); if (state.failed) return ;

                }
                break;
            case 94 :
                // ooa.g:1:743: T_HEAD
                {
                	mT_HEAD(); if (state.failed) return ;

                }
                break;
            case 95 :
                // ooa.g:1:750: T_INDS
                {
                	mT_INDS(); if (state.failed) return ;

                }
                break;
            case 96 :
                // ooa.g:1:757: T_INTER
                {
                	mT_INTER(); if (state.failed) return ;

                }
                break;
            case 97 :
                // ooa.g:1:765: T_LEN
                {
                	mT_LEN(); if (state.failed) return ;

                }
                break;
            case 98 :
                // ooa.g:1:771: T_SEQMOD_MAPOVERRIDE
                {
                	mT_SEQMOD_MAPOVERRIDE(); if (state.failed) return ;

                }
                break;
            case 99 :
                // ooa.g:1:792: T_SUBSET
                {
                	mT_SUBSET(); if (state.failed) return ;

                }
                break;
            case 100 :
                // ooa.g:1:801: T_TAIL
                {
                	mT_TAIL(); if (state.failed) return ;

                }
                break;
            case 101 :
                // ooa.g:1:808: T_UNION
                {
                	mT_UNION(); if (state.failed) return ;

                }
                break;
            case 102 :
                // ooa.g:1:816: T_FOLDLR
                {
                	mT_FOLDLR(); if (state.failed) return ;

                }
                break;
            case 103 :
                // ooa.g:1:825: T_FOLDRL
                {
                	mT_FOLDRL(); if (state.failed) return ;

                }
                break;
            case 104 :
                // ooa.g:1:834: T_DOM
                {
                	mT_DOM(); if (state.failed) return ;

                }
                break;
            case 105 :
                // ooa.g:1:840: T_DOMRESBY
                {
                	mT_DOMRESBY(); if (state.failed) return ;

                }
                break;
            case 106 :
                // ooa.g:1:851: T_DOMRESTO
                {
                	mT_DOMRESTO(); if (state.failed) return ;

                }
                break;
            case 107 :
                // ooa.g:1:862: T_RNG
                {
                	mT_RNG(); if (state.failed) return ;

                }
                break;
            case 108 :
                // ooa.g:1:868: T_RNGRESBY
                {
                	mT_RNGRESBY(); if (state.failed) return ;

                }
                break;
            case 109 :
                // ooa.g:1:879: T_RNGRESTO
                {
                	mT_RNGRESTO(); if (state.failed) return ;

                }
                break;
            case 110 :
                // ooa.g:1:890: T_MERGE
                {
                	mT_MERGE(); if (state.failed) return ;

                }
                break;
            case 111 :
                // ooa.g:1:898: T_MUNION
                {
                	mT_MUNION(); if (state.failed) return ;

                }
                break;
            case 112 :
                // ooa.g:1:907: T_CONSTS
                {
                	mT_CONSTS(); if (state.failed) return ;

                }
                break;
            case 113 :
                // ooa.g:1:916: T_INFTY
                {
                	mT_INFTY(); if (state.failed) return ;

                }
                break;
            case 114 :
                // ooa.g:1:924: FLOAT_OR_INT_OR_RANGE
                {
                	mFLOAT_OR_INT_OR_RANGE(); if (state.failed) return ;

                }
                break;
            case 115 :
                // ooa.g:1:946: T_IDENTIFIER
                {
                	mT_IDENTIFIER(); if (state.failed) return ;

                }
                break;

        }

    }

    // $ANTLR start "synpred1_ooa"
    public void synpred1_ooa_fragment() {
        // ooa.g:1009:9: ( '\"' '\"' )
        // ooa.g:1009:11: '\"' '\"'
        {
        	Match('\"'); if (state.failed) return ;
        	Match('\"'); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred1_ooa"

    // $ANTLR start "synpred2_ooa"
    public void synpred2_ooa_fragment() {
        // ooa.g:1164:5: ( T_POINT T_POINT )
        // ooa.g:1164:6: T_POINT T_POINT
        {
        	mT_POINT(); if (state.failed) return ;
        	mT_POINT(); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred2_ooa"

    // $ANTLR start "synpred3_ooa"
    public void synpred3_ooa_fragment() {
        // ooa.g:1165:6: ( T_POINT T_DIGIT )
        // ooa.g:1165:7: T_POINT T_DIGIT
        {
        	mT_POINT(); if (state.failed) return ;
        	mT_DIGIT(); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred3_ooa"

   	public bool synpred2_ooa() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred2_ooa_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred1_ooa() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred1_ooa_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred3_ooa() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred3_ooa_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


    protected DFA16 dfa16;
	private void InitializeCyclicDFAs()
	{
	    this.dfa16 = new DFA16(this);
	}

    const string DFA16_eotS =
        "\x01\uffff\x01\x30\x01\x32\x01\x2e\x01\uffff\x05\x2e\x01\x4e\x01"+
        "\uffff\x01\x51\x06\uffff\x02\x2e\x01\x5a\x03\x2e\x01\uffff\x01\x62"+
        "\x01\x2e\x01\x2d\x03\x2e\x02\uffff\x03\x2e\x01\x7d\x01\x7f\x01\u0081"+
        "\x02\uffff\x01\x2e\x01\x2d\x01\x2e\x06\uffff\x02\x2e\x01\u0087\x0c"+
        "\x2e\x01\u009b\x01\u009c\x01\x2e\x01\u009f\x01\x2e\x01\u00a2\x01"+
        "\x2e\x02\uffff\x01\u00a5\x06\uffff\x07\x2e\x02\uffff\x06\x2e\x02"+
        "\uffff\x04\x2e\x02\uffff\x04\x2e\x01\u00bd\x01\u00be\x01\u00bf\x04"+
        "\x2e\x01\u00c4\x01\x2e\x01\u00c6\x02\x2e\x01\u00ca\x08\uffff\x01"+
        "\u00cb\x01\uffff\x03\x2e\x01\uffff\x01\x2e\x01\u00d0\x02\x2e\x01"+
        "\u00d3\x07\x2e\x01\u00db\x02\x2e\x01\u00de\x01\u00e0\x01\x2e\x01"+
        "\x68\x02\uffff\x01\u00e2\x01\u00e3\x01\uffff\x01\u00e4\x01\x2e\x01"+
        "\uffff\x01\x2e\x02\uffff\x01\x2e\x01\u00e8\x04\x2e\x01\u00ee\x06"+
        "\x2e\x01\u00f5\x01\u00f6\x02\x2e\x01\u00f9\x01\x2e\x01\u00fb\x01"+
        "\u00fc\x01\u00fd\x01\u00fe\x03\uffff\x01\x2e\x01\u0100\x02\x2e\x01"+
        "\uffff\x01\x2e\x01\uffff\x01\u0104\x01\x2e\x03\uffff\x02\x2e\x01"+
        "\u0108\x01\x2e\x01\uffff\x02\x2e\x01\uffff\x01\u010c\x01\u010d\x04"+
        "\x2e\x01\u0112\x01\uffff\x01\u0113\x01\x2e\x01\uffff\x01\x2e\x01"+
        "\uffff\x01\u0116\x03\uffff\x02\x2e\x01\u0119\x01\uffff\x01\u011a"+
        "\x01\u011b\x01\x2e\x01\u011d\x01\x2e\x01\uffff\x04\x2e\x01\u0123"+
        "\x01\u0124\x02\uffff\x02\x2e\x01\uffff\x01\x2e\x04\uffff\x01\x2e"+
        "\x01\uffff\x01\u0129\x01\u012a\x01\x2e\x01\uffff\x01\u012c\x01\x2e"+
        "\x01\u012e\x01\uffff\x01\u012f\x02\x2e\x02\uffff\x04\x2e\x02\uffff"+
        "\x01\x2e\x01\u0137\x01\uffff\x02\x2e\x03\uffff\x01\x2e\x01\uffff"+
        "\x01\u013b\x01\x2e\x01\u013d\x01\x2e\x01\u013f\x02\uffff\x01\x2e"+
        "\x01\u0141\x02\x2e\x02\uffff\x01\u0144\x01\uffff\x01\u0145\x02\uffff"+
        "\x02\x2e\x01\u0148\x01\u0149\x01\u014a\x01\u014b\x01\u014c\x01\uffff"+
        "\x01\u014d\x01\u014e\x01\u014f\x01\uffff\x01\u0150\x01\uffff\x01"+
        "\u0151\x01\uffff\x01\x2e\x01\uffff\x01\u0153\x01\x2e\x02\uffff\x01"+
        "\u0155\x01\x2e\x0a\uffff\x01\u0157\x01\uffff\x01\x2e\x01\uffff\x01"+
        "\u0159\x01\uffff\x01\u015a\x02\uffff";
    const string DFA16_eofS =
        "\u015b\uffff";
    const string DFA16_minS =
        "\x01\x09\x01\x5b\x01\x7c\x01\x65\x01\uffff\x01\x62\x01\x73\x01"+
        "\x65\x01\x66\x01\x65\x01\x2d\x01\uffff\x01\x2a\x06\uffff\x01\x61"+
        "\x01\x6c\x01\x3e\x01\x61\x01\x69\x01\x65\x01\uffff\x01\x5d\x01\x61"+
        "\x01\x3e\x01\x65\x01\x62\x01\x65\x02\uffff\x01\x68\x01\x61\x01\x69"+
        "\x01\x2d\x01\x3d\x01\x2a\x02\uffff\x01\x64\x01\x2b\x01\x6e\x06\uffff"+
        "\x01\x67\x01\x6f\x01\x24\x01\x6f\x02\x74\x01\x64\x02\x61\x01\x70"+
        "\x01\x61\x01\x73\x01\x6c\x01\x69\x01\x62\x02\x24\x01\x63\x01\x24"+
        "\x01\x6e\x01\x24\x01\x6e\x02\uffff\x01\x3a\x06\uffff\x01\x61\x02"+
        "\x72\x01\x6e\x01\x65\x01\x64\x01\x69\x02\uffff\x01\x6f\x01\x72\x02"+
        "\x6c\x01\x73\x01\x6e\x02\uffff\x01\x70\x01\x72\x01\x64\x01\x6e\x02"+
        "\uffff\x01\x77\x01\x6c\x01\x74\x01\x73\x03\x24\x01\x71\x01\x67\x01"+
        "\x65\x01\x75\x01\x24\x01\x70\x01\x24\x01\x72\x01\x74\x01\x3e\x08"+
        "\uffff\x01\x24\x01\uffff\x02\x69\x01\x6c\x01\uffff\x01\x72\x01\x24"+
        "\x01\x69\x01\x6f\x01\x24\x02\x6c\x02\x61\x02\x74\x01\x66\x01\x24"+
        "\x01\x70\x01\x73\x02\x24\x01\x73\x01\x24\x02\uffff\x02\x24\x01\uffff"+
        "\x01\x24\x01\x74\x01\uffff\x01\x69\x02\uffff\x01\x72\x01\x24\x01"+
        "\x64\x01\x63\x01\x65\x01\x6d\x01\x24\x01\x73\x02\x61\x01\x73\x01"+
        "\x6c\x01\x74\x02\x24\x01\x68\x01\x67\x01\x24\x01\x69\x04\x24\x03"+
        "\uffff\x01\x75\x01\x24\x01\x6e\x01\x65\x01\uffff\x01\x65\x01\uffff"+
        "\x01\x24\x01\x68\x03\uffff\x01\x6f\x01\x6e\x01\x24\x01\x74\x01\uffff"+
        "\x01\x6f\x01\x63\x01\uffff\x02\x24\x01\x63\x01\x64\x01\x69\x01\x65"+
        "\x01\x24\x01\uffff\x01\x24\x01\x65\x01\uffff\x01\x72\x01\uffff\x01"+
        "\x24\x03\uffff\x01\x65\x01\x6f\x01\x24\x01\uffff\x02\x24\x01\x74"+
        "\x01\x24\x01\x73\x01\uffff\x02\x74\x01\x6c\x01\x65\x02\x24\x02\uffff"+
        "\x01\x6f\x01\x65\x01\uffff\x01\x6f\x04\uffff\x01\x69\x01\uffff\x02"+
        "\x24\x01\x73\x01\uffff\x01\x24\x01\x6e\x01\x24\x01\uffff\x01\x24"+
        "\x01\x6e\x01\x6f\x02\uffff\x01\x65\x01\x79\x01\x63\x01\x6d\x02\uffff"+
        "\x01\x74\x01\x24\x01\uffff\x01\x72\x01\x6e\x03\uffff\x01\x73\x01"+
        "\uffff\x01\x24\x01\x73\x01\x24\x01\x6c\x01\x24\x02\uffff\x01\x64"+
        "\x01\x24\x01\x6e\x01\x72\x02\uffff\x01\x24\x01\uffff\x01\x24\x02"+
        "\uffff\x01\x73\x01\x6e\x05\x24\x01\uffff\x03\x24\x01\uffff\x01\x24"+
        "\x01\uffff\x01\x24\x01\uffff\x01\x73\x01\uffff\x01\x24\x01\x65\x02"+
        "\uffff\x01\x24\x01\x73\x0a\uffff\x01\x24\x01\uffff\x01\x73\x01\uffff"+
        "\x01\x24\x01\uffff\x01\x24\x02\uffff";
    const string DFA16_maxS =
        "\x01\x7d\x01\x5b\x01\x7c\x01\x6f\x01\uffff\x01\x75\x01\x76\x01"+
        "\x79\x01\x6e\x01\x75\x01\x3e\x01\uffff\x01\x2f\x06\uffff\x01\x74"+
        "\x01\x78\x01\x3e\x01\x6f\x02\x69\x01\uffff\x01\x5d\x01\x75\x01\x69"+
        "\x01\x6f\x01\x72\x01\x6e\x02\uffff\x01\x79\x01\x61\x01\x69\x01\x3e"+
        "\x01\x3d\x01\x2a\x02\uffff\x01\x64\x01\x69\x01\x6e\x06\uffff\x01"+
        "\x67\x01\x6f\x01\x7a\x01\x73\x02\x74\x01\x64\x02\x61\x01\x70\x01"+
        "\x65\x01\x73\x01\x74\x01\x69\x01\x62\x02\x7a\x01\x63\x01\x7a\x01"+
        "\x76\x01\x7a\x01\x6e\x02\uffff\x01\x3a\x06\uffff\x01\x61\x02\x72"+
        "\x01\x6e\x01\x73\x01\x64\x01\x69\x02\uffff\x01\x6f\x01\x72\x02\x6c"+
        "\x01\x73\x01\x6e\x02\uffff\x01\x70\x01\x74\x01\x64\x01\x6e\x02\uffff"+
        "\x01\x77\x01\x6c\x01\x74\x01\x73\x03\x7a\x01\x71\x01\x67\x01\x65"+
        "\x01\x75\x01\x7a\x01\x70\x01\x7a\x01\x72\x01\x74\x01\x3e\x08\uffff"+
        "\x01\x7a\x01\uffff\x02\x69\x01\x6c\x01\uffff\x01\x72\x01\x7a\x01"+
        "\x69\x01\x6f\x01\x7a\x02\x6c\x02\x61\x02\x74\x01\x66\x01\x7a\x01"+
        "\x70\x01\x73\x02\x7a\x01\x73\x01\x7a\x02\uffff\x02\x7a\x01\uffff"+
        "\x01\x7a\x01\x74\x01\uffff\x01\x69\x02\uffff\x01\x72\x01\x7a\x01"+
        "\x64\x01\x73\x01\x65\x01\x6d\x01\x7a\x01\x73\x02\x61\x01\x73\x01"+
        "\x6c\x01\x74\x02\x7a\x01\x68\x01\x67\x01\x7a\x01\x69\x04\x7a\x03"+
        "\uffff\x01\x75\x01\x7a\x01\x6e\x01\x65\x01\uffff\x01\x65\x01\uffff"+
        "\x01\x7a\x01\x68\x03\uffff\x01\x6f\x01\x6e\x01\x7a\x01\x74\x01\uffff"+
        "\x01\x6f\x01\x63\x01\uffff\x02\x7a\x01\x63\x01\x64\x01\x69\x01\x65"+
        "\x01\x7a\x01\uffff\x01\x7a\x01\x65\x01\uffff\x01\x72\x01\uffff\x01"+
        "\x7a\x03\uffff\x01\x65\x01\x6f\x01\x7a\x01\uffff\x02\x7a\x01\x74"+
        "\x01\x7a\x01\x73\x01\uffff\x02\x74\x01\x6c\x01\x65\x02\x7a\x02\uffff"+
        "\x01\x6f\x01\x65\x01\uffff\x01\x6f\x04\uffff\x01\x69\x01\uffff\x02"+
        "\x7a\x01\x73\x01\uffff\x01\x7a\x01\x6e\x01\x7a\x01\uffff\x01\x7a"+
        "\x01\x6e\x01\x6f\x02\uffff\x01\x65\x01\x79\x01\x63\x01\x6d\x02\uffff"+
        "\x01\x74\x01\x7a\x01\uffff\x01\x72\x01\x6e\x03\uffff\x01\x73\x01"+
        "\uffff\x01\x7a\x01\x73\x01\x7a\x01\x6c\x01\x7a\x02\uffff\x01\x64"+
        "\x01\x7a\x01\x6e\x01\x72\x02\uffff\x01\x7a\x01\uffff\x01\x7a\x02"+
        "\uffff\x01\x73\x01\x6e\x05\x7a\x01\uffff\x03\x7a\x01\uffff\x01\x7a"+
        "\x01\uffff\x01\x7a\x01\uffff\x01\x73\x01\uffff\x01\x7a\x01\x65\x02"+
        "\uffff\x01\x7a\x01\x73\x0a\uffff\x01\x7a\x01\uffff\x01\x73\x01\uffff"+
        "\x01\x7a\x01\uffff\x01\x7a\x02\uffff";
    const string DFA16_acceptS =
        "\x04\uffff\x01\x04\x06\uffff\x01\x0b\x01\uffff\x01\x0d\x01\x0e"+
        "\x01\x0f\x01\x16\x01\x17\x01\x19\x06\uffff\x01\x2b\x06\uffff\x01"+
        "\x38\x01\x3d\x06\uffff\x01\x58\x01\x5a\x03\uffff\x01\x72\x01\x73"+
        "\x01\x01\x01\x14\x01\x02\x01\x39\x16\uffff\x01\x0a\x01\x12\x01\uffff"+
        "\x01\x67\x01\x6c\x01\x18\x01\x0c\x01\x36\x01\x4d\x07\uffff\x01\x48"+
        "\x01\x21\x06\uffff\x01\x32\x01\x2c\x04\uffff\x01\x2e\x01\x71\x11"+
        "\uffff\x01\x4a\x01\x69\x01\x6a\x01\x51\x01\x4f\x01\x4e\x01\x54\x01"+
        "\x55\x01\uffff\x01\x62\x03\uffff\x01\x05\x13\uffff\x01\x27\x01\x26"+
        "\x02\uffff\x01\x1e\x02\uffff\x01\x56\x01\uffff\x01\x66\x01\x6d\x17"+
        "\uffff\x01\x34\x01\x35\x01\x4b\x04\uffff\x01\x42\x01\uffff\x01\x64"+
        "\x02\uffff\x01\x47\x01\x52\x01\x5e\x04\uffff\x01\x4c\x02\uffff\x01"+
        "\x46\x07\uffff\x01\x3c\x02\uffff\x01\x08\x01\uffff\x01\x28\x01\uffff"+
        "\x01\x09\x01\x68\x01\x50\x03\uffff\x01\x1c\x05\uffff\x01\x20\x06"+
        "\uffff\x01\x61\x01\x2d\x02\uffff\x01\x53\x01\uffff\x01\x30\x01\x31"+
        "\x01\x49\x01\x33\x01\uffff\x01\x6b\x03\uffff\x01\x44\x03\uffff\x01"+
        "\x15\x03\uffff\x01\x06\x01\x1a\x04\uffff\x01\x3b\x01\x3f\x02\uffff"+
        "\x01\x5f\x02\uffff\x01\x1b\x01\x57\x01\x59\x01\uffff\x01\x1f\x05"+
        "\uffff\x01\x29\x01\x2a\x04\uffff\x01\x40\x01\x41\x01\uffff\x01\x45"+
        "\x01\uffff\x01\x03\x01\x10\x07\uffff\x01\x60\x03\uffff\x01\x5d\x01"+
        "\uffff\x01\x23\x01\uffff\x01\x25\x01\uffff\x01\x6e\x02\uffff\x01"+
        "\x43\x01\x65\x02\uffff\x01\x3a\x01\x07\x01\x3e\x01\x1d\x01\x63\x01"+
        "\x5b\x01\x5c\x01\x70\x01\x22\x01\x24\x01\uffff\x01\x6f\x01\uffff"+
        "\x01\x11\x01\uffff\x01\x2f\x01\uffff\x01\x13\x01\x37";
    const string DFA16_specialS =
        "\u015b\uffff}>";
    static readonly string[] DFA16_transitionS = {
            "\x02\x0b\x01\uffff\x02\x0b\x12\uffff\x01\x0b\x01\uffff\x01"+
            "\x0f\x01\x0d\x01\x2e\x01\uffff\x01\x04\x01\x0e\x01\x19\x01\x20"+
            "\x01\x27\x01\x2b\x01\x12\x01\x1c\x01\x2d\x01\x0c\x0a\x2d\x01"+
            "\x0a\x01\x21\x01\x25\x01\x15\x01\x26\x02\uffff\x1a\x2e\x01\x1a"+
            "\x01\x29\x01\x02\x01\x28\x01\x2e\x01\uffff\x01\x05\x01\x03\x01"+
            "\x13\x01\x09\x01\x14\x01\x16\x01\x2e\x01\x2a\x01\x08\x01\x2e"+
            "\x01\x17\x01\x18\x01\x1b\x01\x1d\x01\x1e\x01\x2e\x01\x06\x01"+
            "\x1f\x01\x07\x01\x22\x01\x2c\x01\x23\x01\x24\x03\x2e\x01\x10"+
            "\x01\x01\x01\x11",
            "\x01\x2f",
            "\x01\x31",
            "\x01\x33\x09\uffff\x01\x34",
            "",
            "\x01\x36\x01\x37\x0a\uffff\x01\x39\x04\uffff\x01\x35\x01\uffff"+
            "\x01\x38",
            "\x01\x3c\x01\uffff\x01\x3b\x01\x3a",
            "\x01\x3f\x05\uffff\x01\x40\x08\uffff\x01\x3d\x01\x41\x03\uffff"+
            "\x01\x3e",
            "\x01\x43\x07\uffff\x01\x42",
            "\x01\x44\x03\uffff\x01\x46\x05\uffff\x01\x45\x04\uffff\x01"+
            "\x47\x01\x48",
            "\x01\x4d\x0c\uffff\x01\x49\x01\uffff\x01\x4c\x01\x4a\x01\x4b",
            "",
            "\x01\x4f\x04\uffff\x01\x50",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x54\x06\uffff\x01\x52\x06\uffff\x01\x55\x04\uffff\x01"+
            "\x53",
            "\x01\x56\x01\uffff\x01\x57\x09\uffff\x01\x58",
            "\x01\x59",
            "\x01\x5d\x0a\uffff\x01\x5b\x02\uffff\x01\x5c",
            "\x01\x5e",
            "\x01\x60\x03\uffff\x01\x5f",
            "",
            "\x01\x61",
            "\x01\x63\x03\uffff\x01\x64\x09\uffff\x01\x65\x05\uffff\x01"+
            "\x66",
            "\x01\x67\x2a\uffff\x01\x68",
            "\x01\x69\x03\uffff\x01\x6a\x05\uffff\x01\x6b",
            "\x01\x6c\x01\uffff\x01\x6d\x01\uffff\x01\x6e\x0b\uffff\x01"+
            "\x6f",
            "\x01\x70\x08\uffff\x01\x71",
            "",
            "",
            "\x01\x72\x03\uffff\x01\x76\x02\uffff\x01\x74\x02\uffff\x01"+
            "\x73\x06\uffff\x01\x75",
            "\x01\x77",
            "\x01\x78",
            "\x01\x7b\x0c\uffff\x01\x7c\x02\uffff\x01\x79\x01\x7a",
            "\x01\x7e",
            "\x01\u0080",
            "",
            "",
            "\x01\u0082",
            "\x01\u0083\x3d\uffff\x01\x68",
            "\x01\u0084",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\u0085",
            "\x01\u0086",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0088\x03\uffff\x01\u0089",
            "\x01\u008a",
            "\x01\u008b",
            "\x01\u008c",
            "\x01\u008d",
            "\x01\u008e",
            "\x01\u008f",
            "\x01\u0091\x03\uffff\x01\u0090",
            "\x01\u0092",
            "\x01\u0093\x07\uffff\x01\u0094",
            "\x01\u0095",
            "\x01\u0096",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x02\x2e\x01\u0097\x01\u0099\x01\x2e\x01\u009a"+
            "\x0d\x2e\x01\u0098\x06\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u009d",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x0c\x2e\x01\u009e\x0d\x2e",
            "\x01\u00a1\x07\uffff\x01\u00a0",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00a3",
            "",
            "",
            "\x01\u00a4",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\u00a6",
            "\x01\u00a7",
            "\x01\u00a8",
            "\x01\u00a9",
            "\x01\u00ab\x0d\uffff\x01\u00aa",
            "\x01\u00ac",
            "\x01\u00ad",
            "",
            "",
            "\x01\u00ae",
            "\x01\u00af",
            "\x01\u00b0",
            "\x01\u00b1",
            "\x01\u00b2",
            "\x01\u00b3",
            "",
            "",
            "\x01\u00b4",
            "\x01\u00b6\x01\uffff\x01\u00b5",
            "\x01\u00b7",
            "\x01\u00b8",
            "",
            "",
            "\x01\u00b9",
            "\x01\u00ba",
            "\x01\u00bb",
            "\x01\u00bc",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00c0",
            "\x01\u00c1",
            "\x01\u00c2",
            "\x01\u00c3",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00c5",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00c7",
            "\x01\u00c8",
            "\x01\u00c9",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\u00cc",
            "\x01\u00cd",
            "\x01\u00ce",
            "",
            "\x01\u00cf",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00d1",
            "\x01\u00d2",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00d4",
            "\x01\u00d5",
            "\x01\u00d6",
            "\x01\u00d7",
            "\x01\u00d8",
            "\x01\u00d9",
            "\x01\u00da",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00dc",
            "\x01\u00dd",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x04\x2e\x01\u00df\x15\x2e",
            "\x01\u00e1",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00e5",
            "",
            "\x01\u00e6",
            "",
            "",
            "\x01\u00e7",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00e9",
            "\x01\u00ea\x0f\uffff\x01\u00eb",
            "\x01\u00ec",
            "\x01\u00ed",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00ef",
            "\x01\u00f0",
            "\x01\u00f1",
            "\x01\u00f2",
            "\x01\u00f3",
            "\x01\u00f4",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00f7",
            "\x01\u00f8",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u00fa",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "",
            "\x01\u00ff",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0101",
            "\x01\u0102",
            "",
            "\x01\u0103",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0105",
            "",
            "",
            "",
            "\x01\u0106",
            "\x01\u0107",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0109",
            "",
            "\x01\u010a",
            "\x01\u010b",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u010e",
            "\x01\u010f",
            "\x01\u0110",
            "\x01\u0111",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0114",
            "",
            "\x01\u0115",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "",
            "\x01\u0117",
            "\x01\u0118",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u011c",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u011e",
            "",
            "\x01\u011f",
            "\x01\u0120",
            "\x01\u0121",
            "\x01\u0122",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "\x01\u0125",
            "\x01\u0126",
            "",
            "\x01\u0127",
            "",
            "",
            "",
            "",
            "\x01\u0128",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u012b",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u012d",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0130",
            "\x01\u0131",
            "",
            "",
            "\x01\u0132",
            "\x01\u0133",
            "\x01\u0134",
            "\x01\u0135",
            "",
            "",
            "\x01\u0136",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\u0138",
            "\x01\u0139",
            "",
            "",
            "",
            "\x01\u013a",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u013c",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u013e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "\x01\u0140",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0142",
            "\x01\u0143",
            "",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "",
            "\x01\u0146",
            "\x01\u0147",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\u0152",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0154",
            "",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "\x01\u0156",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\u0158",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            "\x01\x2e\x0b\uffff\x0a\x2e\x07\uffff\x1a\x2e\x04\uffff\x01"+
            "\x2e\x01\uffff\x1a\x2e",
            "",
            ""
    };

    static readonly short[] DFA16_eot = DFA.UnpackEncodedString(DFA16_eotS);
    static readonly short[] DFA16_eof = DFA.UnpackEncodedString(DFA16_eofS);
    static readonly char[] DFA16_min = DFA.UnpackEncodedStringToUnsignedChars(DFA16_minS);
    static readonly char[] DFA16_max = DFA.UnpackEncodedStringToUnsignedChars(DFA16_maxS);
    static readonly short[] DFA16_accept = DFA.UnpackEncodedString(DFA16_acceptS);
    static readonly short[] DFA16_special = DFA.UnpackEncodedString(DFA16_specialS);
    static readonly short[][] DFA16_transition = DFA.UnpackEncodedStringArray(DFA16_transitionS);

    protected class DFA16 : DFA
    {
        public DFA16(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 16;
            this.eot = DFA16_eot;
            this.eof = DFA16_eof;
            this.min = DFA16_min;
            this.max = DFA16_max;
            this.accept = DFA16_accept;
            this.special = DFA16_special;
            this.transition = DFA16_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | T__123 | T__124 | T__125 | T__126 | T_WS | T_COMMENT | LINE_COMMENT | T_PRIMED | T_STRINGLITERAL | T_ABORT | T_ACTIONS | T_ASSIGNMENT | T_AUTOCONS | T_BAR | T_BOOL | T_CBRL | T_CBRR | T_COLON | T_COMMA | T_CONT | T_CHAR | T_CTRL | T_SYSTEM | T_DO | T_ELSE | T_END | T_EQUAL | T_EXISTS | T_FLOAT | T_FORALL | T_FALSE | T_IF | T_IN | T_INT | T_KILL | T_LIST | T_LPAREN | T_LSQPAREN | T_MAP | T_MAPS | T_METHODS | T_NEW | T_NIL | T_NONDET | T_OBS | T_OD | T_OF | T_PRIO | T_REQUIRES | T_RPAREN | T_RSQPAREN | T_QUANTITY | T_SELF | T_SET | T_SEMICOLON | T_STATIC | T_SKIP | T_THEN | T_TRUE | T_TO | T_TYPES | T_VAR | T_WITH | T_AND | T_BIIMPLIES | T_IMPLIES | T_NOT | T_NOTEQUAL | T_OR | T_ABS | T_DIV | T_GREATER | T_GREATEREQUAL | T_IDIV | T_LESS | T_LESSEQUAL | T_MOD | T_POW | T_PROD | T_DERIV | T_CARD | T_CONC | T_DCONC | T_DIFF | T_DINTER | T_DUNION | T_ELEMS | T_HEAD | T_INDS | T_INTER | T_LEN | T_SEQMOD_MAPOVERRIDE | T_SUBSET | T_TAIL | T_UNION | T_FOLDLR | T_FOLDRL | T_DOM | T_DOMRESBY | T_DOMRESTO | T_RNG | T_RNGRESBY | T_RNGRESTO | T_MERGE | T_MUNION | T_CONSTS | T_INFTY | FLOAT_OR_INT_OR_RANGE | T_IDENTIFIER );"; }
        }

    }

 
    
}
}