// $ANTLR 3.3 Nov 30, 2010 12:50:56 src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g 2011-12-19 14:53:14
 package org.simantics.graph.compiler.internal.parsing; 

import gnu.trove.list.array.*;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"unused", "unchecked", "rawtypes"})
public class GraphLexer extends Lexer {
    public static final int EOF=-1;
    public static final int T__65=65;
    public static final int T__66=66;
    public static final int T__67=67;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__70=70;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int T__73=73;
    public static final int T__74=74;
    public static final int T__75=75;
    public static final int T__76=76;
    public static final int T__77=77;
    public static final int T__78=78;
    public static final int T__79=79;
    public static final int T__80=80;
    public static final int INDENT=4;
    public static final int DEDENT=5;
    public static final int FILE=6;
    public static final int RESOURCE=7;
    public static final int PROPERTY=8;
    public static final int VARIABLE=9;
    public static final int EMBEDDED_VALUE=10;
    public static final int EMBEDDED_TYPE=11;
    public static final int TEMPLATE_INSTANCE=12;
    public static final int TEMPLATE_DEFINITION=13;
    public static final int BLANK=14;
    public static final int REF=15;
    public static final int EQUALS=16;
    public static final int INSTANCE_OF=17;
    public static final int INHERITS=18;
    public static final int SUBRELATION_OF=19;
    public static final int HAS_DOMAIN=20;
    public static final int HAS_RANGE=21;
    public static final int DOMAIN_OF=22;
    public static final int REQUIRES_VALUE_TYPE=23;
    public static final int TYPE_DEFINITIONS=24;
    public static final int TYPE_DEFINITION=25;
    public static final int UNION_TYPE=26;
    public static final int RECORD_TYPE=27;
    public static final int TUPLE_TYPE=28;
    public static final int ARRAY_TYPE=29;
    public static final int TYPE_REFERENCE=30;
    public static final int TYPE_ANNOTATION=31;
    public static final int TYPE_COMPONENT=32;
    public static final int VALUE_DEFINITIONS=33;
    public static final int VALUE_DEFINITION=34;
    public static final int NO_VALUE=35;
    public static final int VARIANT=36;
    public static final int ARRAY=37;
    public static final int TUPLE=38;
    public static final int TAGGED_VALUE=39;
    public static final int RECORD=40;
    public static final int MAP=41;
    public static final int ASSIGNMENT=42;
    public static final int TRUE=43;
    public static final int FALSE=44;
    public static final int ID=45;
    public static final int COMMENT=46;
    public static final int WS=47;
    public static final int LPAREN=48;
    public static final int RPAREN=49;
    public static final int LBRACKET=50;
    public static final int RBRACKET=51;
    public static final int LCURLY=52;
    public static final int RCURLY=53;
    public static final int INT=54;
    public static final int INT_RANGE=55;
    public static final int FLOAT=56;
    public static final int RANGE=57;
    public static final int NEWLINE=58;
    public static final int EXPONENT=59;
    public static final int ESC_SEQ=60;
    public static final int STRING=61;
    public static final int URI=62;
    public static final int HEX_DIGIT=63;
    public static final int UNICODE_ESC=64;

    int inParen = 0;

    TIntArrayList iStack = new TIntArrayList();
    { iStack.add(0); }

    List tokens = new ArrayList();
    public void emit(Token token) {
        state.token = token;
        tokens.add(token);
    }
    public Token nextToken() {
        if(tokens.isEmpty()) {
            super.nextToken();
            if ( tokens.isEmpty() ) {
                /* When end-of-file is encountered, we 
                   emit balancing number of DEDENT tokens.
                */
                if(iStack.size() <= 1)
                    return getEOFToken();
                else {                
                    while(iStack.size() > 1) {
                        iStack.removeAt(iStack.size()-1);
                        state.type = DEDENT;
                        emit();
                    }
                    iStack.clear();
                }
            } 
        }
        return (Token)tokens.remove(0);
    }



    // delegates
    // delegators

    public GraphLexer() {;} 
    public GraphLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public GraphLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g"; }

    // $ANTLR start "T__65"
    public final void mT__65() throws RecognitionException {
        try {
            int _type = T__65;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:46:7: ( '@' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:46:9: '@'
            {
            match('@'); 

            }

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

    // $ANTLR start "T__66"
    public final void mT__66() throws RecognitionException {
        try {
            int _type = T__66;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:47:7: ( '.' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:47:9: '.'
            {
            match('.'); 

            }

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

    // $ANTLR start "T__67"
    public final void mT__67() throws RecognitionException {
        try {
            int _type = T__67;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:48:7: ( '<T' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:48:9: '<T'
            {
            match("<T"); 


            }

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

    // $ANTLR start "T__68"
    public final void mT__68() throws RecognitionException {
        try {
            int _type = T__68;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:49:7: ( '<R' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:49:9: '<R'
            {
            match("<R"); 


            }

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

    // $ANTLR start "T__69"
    public final void mT__69() throws RecognitionException {
        try {
            int _type = T__69;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:50:7: ( '<--' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:50:9: '<--'
            {
            match("<--"); 


            }

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

    // $ANTLR start "T__70"
    public final void mT__70() throws RecognitionException {
        try {
            int _type = T__70;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:51:7: ( '-->' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:51:9: '-->'
            {
            match("-->"); 


            }

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

    // $ANTLR start "T__71"
    public final void mT__71() throws RecognitionException {
        try {
            int _type = T__71;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:52:7: ( '==>' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:52:9: '==>'
            {
            match("==>"); 


            }

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

    // $ANTLR start "T__72"
    public final void mT__72() throws RecognitionException {
        try {
            int _type = T__72;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:53:7: ( '>--' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:53:9: '>--'
            {
            match(">--"); 


            }

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

    // $ANTLR start "T__73"
    public final void mT__73() throws RecognitionException {
        try {
            int _type = T__73;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:54:7: ( ':' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:54:9: ':'
            {
            match(':'); 

            }

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

    // $ANTLR start "T__74"
    public final void mT__74() throws RecognitionException {
        try {
            int _type = T__74;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:55:7: ( '=' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:55:9: '='
            {
            match('='); 

            }

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

    // $ANTLR start "T__75"
    public final void mT__75() throws RecognitionException {
        try {
            int _type = T__75;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:56:7: ( '%' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:56:9: '%'
            {
            match('%'); 

            }

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

    // $ANTLR start "T__76"
    public final void mT__76() throws RecognitionException {
        try {
            int _type = T__76;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:57:7: ( '$' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:57:9: '$'
            {
            match('$'); 

            }

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

    // $ANTLR start "T__77"
    public final void mT__77() throws RecognitionException {
        try {
            int _type = T__77;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:58:7: ( '|' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:58:9: '|'
            {
            match('|'); 

            }

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

    // $ANTLR start "T__78"
    public final void mT__78() throws RecognitionException {
        try {
            int _type = T__78;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:59:7: ( ',' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:59:9: ','
            {
            match(','); 

            }

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

    // $ANTLR start "T__79"
    public final void mT__79() throws RecognitionException {
        try {
            int _type = T__79;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:60:7: ( 'true' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:60:9: 'true'
            {
            match("true"); 


            }

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

    // $ANTLR start "T__80"
    public final void mT__80() throws RecognitionException {
        try {
            int _type = T__80;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:61:7: ( 'false' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:61:9: 'false'
            {
            match("false"); 


            }

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

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:108:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:108:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:108:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

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


                switch (alt1) {
            	case 1 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:
            	    {
            	    if ( (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();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

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


            }

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

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:112:5: ( '//' (~ ( '\\n' ) )* | '/*' ( options {greedy=false; } : . )* '*/' )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0=='/') ) {
                int LA4_1 = input.LA(2);

                if ( (LA4_1=='/') ) {
                    alt4=1;
                }
                else if ( (LA4_1=='*') ) {
                    alt4=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 4, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:112:9: '//' (~ ( '\\n' ) )*
                    {
                    match("//"); 

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:112:14: (~ ( '\\n' ) )*
                    loop2:
                    do {
                        int alt2=2;
                        int LA2_0 = input.LA(1);

                        if ( ((LA2_0>='\u0000' && LA2_0<='\t')||(LA2_0>='\u000B' && LA2_0<='\uFFFF')) ) {
                            alt2=1;
                        }


                        switch (alt2) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:112:14: ~ ( '\\n' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop2;
                        }
                    } while (true);

                    _channel=HIDDEN;

                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:113:9: '/*' ( options {greedy=false; } : . )* '*/'
                    {
                    match("/*"); 

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:113:14: ( options {greedy=false; } : . )*
                    loop3:
                    do {
                        int alt3=2;
                        int LA3_0 = input.LA(1);

                        if ( (LA3_0=='*') ) {
                            int LA3_1 = input.LA(2);

                            if ( (LA3_1=='/') ) {
                                alt3=2;
                            }
                            else if ( ((LA3_1>='\u0000' && LA3_1<='.')||(LA3_1>='0' && LA3_1<='\uFFFF')) ) {
                                alt3=1;
                            }


                        }
                        else if ( ((LA3_0>='\u0000' && LA3_0<=')')||(LA3_0>='+' && LA3_0<='\uFFFF')) ) {
                            alt3=1;
                        }


                        switch (alt3) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:113:42: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop3;
                        }
                    } while (true);

                    match("*/"); 

                    _channel=HIDDEN;

                    }
                    break;

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

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:116:5: ( ( ' ' | '\\t' | '\\r' ) )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:116:7: ( ' ' | '\\t' | '\\r' )
            {
            if ( input.LA(1)=='\t'||input.LA(1)=='\r'||input.LA(1)==' ' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            _channel=HIDDEN;

            }

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

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:122:11: ( '(' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:122:13: '('
            {
            match('('); 
             ++ inParen; 

            }

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

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:123:11: ( ')' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:123:13: ')'
            {
            match(')'); 
             -- inParen; 

            }

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

    // $ANTLR start "LBRACKET"
    public final void mLBRACKET() throws RecognitionException {
        try {
            int _type = LBRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:124:11: ( '[' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:124:13: '['
            {
            match('['); 
             ++ inParen; 

            }

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

    // $ANTLR start "RBRACKET"
    public final void mRBRACKET() throws RecognitionException {
        try {
            int _type = RBRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:125:11: ( ']' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:125:13: ']'
            {
            match(']'); 
             -- inParen; 

            }

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

    // $ANTLR start "LCURLY"
    public final void mLCURLY() throws RecognitionException {
        try {
            int _type = LCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:126:11: ( '{' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:126:13: '{'
            {
            match('{'); 
             ++ inParen; 

            }

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

    // $ANTLR start "RCURLY"
    public final void mRCURLY() throws RecognitionException {
        try {
            int _type = RCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:127:11: ( '}' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:127:13: '}'
            {
            match('}'); 
             -- inParen; 

            }

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

    // $ANTLR start "INT_RANGE"
    public final void mINT_RANGE() throws RecognitionException {
        try {
            int _type = INT_RANGE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:129:11: ( INT '..' ( INT )? | '..' INT )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0=='-'||(LA6_0>='0' && LA6_0<='9')) ) {
                alt6=1;
            }
            else if ( (LA6_0=='.') ) {
                alt6=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }
            switch (alt6) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:129:13: INT '..' ( INT )?
                    {
                    mINT(); 
                    match(".."); 

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:129:22: ( INT )?
                    int alt5=2;
                    int LA5_0 = input.LA(1);

                    if ( (LA5_0=='-'||(LA5_0>='0' && LA5_0<='9')) ) {
                        alt5=1;
                    }
                    switch (alt5) {
                        case 1 :
                            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:129:22: INT
                            {
                            mINT(); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:130:13: '..' INT
                    {
                    match(".."); 

                    mINT(); 

                    }
                    break;

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

    // $ANTLR start "RANGE"
    public final void mRANGE() throws RecognitionException {
        try {
            int _type = RANGE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:132:11: ( FLOAT '..' ( FLOAT | INT )? | '..' FLOAT | INT '..' FLOAT )
            int alt8=3;
            alt8 = dfa8.predict(input);
            switch (alt8) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:132:13: FLOAT '..' ( FLOAT | INT )?
                    {
                    mFLOAT(); 
                    match(".."); 

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:132:24: ( FLOAT | INT )?
                    int alt7=3;
                    alt7 = dfa7.predict(input);
                    switch (alt7) {
                        case 1 :
                            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:132:25: FLOAT
                            {
                            mFLOAT(); 

                            }
                            break;
                        case 2 :
                            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:132:33: INT
                            {
                            mINT(); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:133:13: '..' FLOAT
                    {
                    match(".."); 

                    mFLOAT(); 

                    }
                    break;
                case 3 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:134:13: INT '..' FLOAT
                    {
                    mINT(); 
                    match(".."); 

                    mFLOAT(); 

                    }
                    break;

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

    // $ANTLR start "NEWLINE"
    public final void mNEWLINE() throws RecognitionException {
        try {
            int _type = NEWLINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
             int spaces = 0; 
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:139:5: ( '\\n' ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )* )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:139:7: '\\n' ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )*
            {
            match('\n'); 
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:140:7: ( ' ' | '//' (~ ( '\\n' ) )* '\\n' | '/*' ( options {greedy=false; } : . )* '*/' | '\\r' | '\\n' )*
            loop11:
            do {
                int alt11=6;
                switch ( input.LA(1) ) {
                case ' ':
                    {
                    alt11=1;
                    }
                    break;
                case '/':
                    {
                    int LA11_3 = input.LA(2);

                    if ( (LA11_3=='/') ) {
                        alt11=2;
                    }
                    else if ( (LA11_3=='*') ) {
                        alt11=3;
                    }


                    }
                    break;
                case '\r':
                    {
                    alt11=4;
                    }
                    break;
                case '\n':
                    {
                    alt11=5;
                    }
                    break;

                }

                switch (alt11) {
            	case 1 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:140:9: ' '
            	    {
            	    match(' '); 
            	     ++spaces; 

            	    }
            	    break;
            	case 2 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:141:9: '//' (~ ( '\\n' ) )* '\\n'
            	    {
            	    match("//"); 

            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:141:14: (~ ( '\\n' ) )*
            	    loop9:
            	    do {
            	        int alt9=2;
            	        int LA9_0 = input.LA(1);

            	        if ( ((LA9_0>='\u0000' && LA9_0<='\t')||(LA9_0>='\u000B' && LA9_0<='\uFFFF')) ) {
            	            alt9=1;
            	        }


            	        switch (alt9) {
            	    	case 1 :
            	    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:141:14: ~ ( '\\n' )
            	    	    {
            	    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) {
            	    	        input.consume();

            	    	    }
            	    	    else {
            	    	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	    	        recover(mse);
            	    	        throw mse;}


            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop9;
            	        }
            	    } while (true);

            	    match('\n'); 
            	     spaces = 0; 

            	    }
            	    break;
            	case 3 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:142:9: '/*' ( options {greedy=false; } : . )* '*/'
            	    {
            	    match("/*"); 

            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:142:14: ( options {greedy=false; } : . )*
            	    loop10:
            	    do {
            	        int alt10=2;
            	        int LA10_0 = input.LA(1);

            	        if ( (LA10_0=='*') ) {
            	            int LA10_1 = input.LA(2);

            	            if ( (LA10_1=='/') ) {
            	                alt10=2;
            	            }
            	            else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) {
            	                alt10=1;
            	            }


            	        }
            	        else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) {
            	            alt10=1;
            	        }


            	        switch (alt10) {
            	    	case 1 :
            	    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:142:42: .
            	    	    {
            	    	    matchAny(); 

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop10;
            	        }
            	    } while (true);

            	    match("*/"); 


            	    }
            	    break;
            	case 4 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:143:9: '\\r'
            	    {
            	    match('\r'); 

            	    }
            	    break;
            	case 5 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:144:9: '\\n'
            	    {
            	    match('\n'); 
            	     spaces = 0; 

            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);

             
                      int c = input.LA(1);
                      
                      if(inParen > 0) {
                          _channel = HIDDEN;
                      }
                      else if(c == EOF) {
                          while(iStack.size() > 1) {
                              iStack.removeAt(iStack.size()-1);
                              state.type = DEDENT;
                              emit();
                          }
                          _channel = HIDDEN;
                          iStack.clear();
                      }
                      else {
                          int stackTop = iStack.get(iStack.size()-1);
                          if(spaces > stackTop) {
                              iStack.add(spaces);
                              _type = INDENT;
                          }
                          else if(spaces < stackTop) {
                              while(spaces < iStack.get(iStack.size()-1)) {
                                  iStack.removeAt(iStack.size()-1);
                                  state.type = DEDENT;
                                  emit();
                              }
                              state.type = NEWLINE;
                              emit();
                              // TODO check that spaces == iStack.get(iStack.size()-1)
                          }
                      }
                  

            }

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

    // $ANTLR start "INDENT"
    public final void mINDENT() throws RecognitionException {
        try {
            int _type = INDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:181:7: ({...}? => 'INDENT' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:181:9: {...}? => 'INDENT'
            {
            if ( !(( false )) ) {
                throw new FailedPredicateException(input, "INDENT", " false ");
            }
            match("INDENT"); 


            }

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

    // $ANTLR start "DEDENT"
    public final void mDEDENT() throws RecognitionException {
        try {
            int _type = DEDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:182:7: ({...}? => 'DEDENT' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:182:9: {...}? => 'DEDENT'
            {
            if ( !(( false )) ) {
                throw new FailedPredicateException(input, "DEDENT", " false ");
            }
            match("DEDENT"); 


            }

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

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:5: ( ( '-' )? ( '0' .. '9' )+ )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:7: ( '-' )? ( '0' .. '9' )+
            {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:7: ( '-' )?
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0=='-') ) {
                alt12=1;
            }
            switch (alt12) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:7: '-'
                    {
                    match('-'); 

                    }
                    break;

            }

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:12: ( '0' .. '9' )+
            int cnt13=0;
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( ((LA13_0>='0' && LA13_0<='9')) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:184:12: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt13 >= 1 ) break loop13;
                        EarlyExitException eee =
                            new EarlyExitException(13, input);
                        throw eee;
                }
                cnt13++;
            } while (true);


            }

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

    // $ANTLR start "FLOAT"
    public final void mFLOAT() throws RecognitionException {
        try {
            int _type = FLOAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:188:5: ( ( '-' )? ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT ) )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:188:7: ( '-' )? ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )
            {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:188:7: ( '-' )?
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0=='-') ) {
                alt14=1;
            }
            switch (alt14) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:188:7: '-'
                    {
                    match('-'); 

                    }
                    break;

            }

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )
            int alt19=2;
            alt19 = dfa19.predict(input);
            switch (alt19) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:7: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )?
                    {
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:7: ( '0' .. '9' )+
                    int cnt15=0;
                    loop15:
                    do {
                        int alt15=2;
                        int LA15_0 = input.LA(1);

                        if ( ((LA15_0>='0' && LA15_0<='9')) ) {
                            alt15=1;
                        }


                        switch (alt15) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:8: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt15 >= 1 ) break loop15;
                                EarlyExitException eee =
                                    new EarlyExitException(15, input);
                                throw eee;
                        }
                        cnt15++;
                    } while (true);

                    match('.'); 
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:23: ( '0' .. '9' )*
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( ((LA16_0>='0' && LA16_0<='9')) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:24: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop16;
                        }
                    } while (true);

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:35: ( EXPONENT )?
                    int alt17=2;
                    int LA17_0 = input.LA(1);

                    if ( (LA17_0=='E'||LA17_0=='e') ) {
                        alt17=1;
                    }
                    switch (alt17) {
                        case 1 :
                            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:189:35: EXPONENT
                            {
                            mEXPONENT(); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:190:7: ( '0' .. '9' )+ EXPONENT
                    {
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:190:7: ( '0' .. '9' )+
                    int cnt18=0;
                    loop18:
                    do {
                        int alt18=2;
                        int LA18_0 = input.LA(1);

                        if ( ((LA18_0>='0' && LA18_0<='9')) ) {
                            alt18=1;
                        }


                        switch (alt18) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:190:8: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt18 >= 1 ) break loop18;
                                EarlyExitException eee =
                                    new EarlyExitException(18, input);
                                throw eee;
                        }
                        cnt18++;
                    } while (true);

                    mEXPONENT(); 

                    }
                    break;

            }


            }

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

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:195:5: ( '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0=='\"') ) {
                int LA22_1 = input.LA(2);

                if ( (LA22_1=='\"') ) {
                    int LA22_2 = input.LA(3);

                    if ( (LA22_2=='\"') ) {
                        alt22=2;
                    }
                    else {
                        alt22=1;}
                }
                else if ( ((LA22_1>='\u0000' && LA22_1<='!')||(LA22_1>='#' && LA22_1<='\uFFFF')) ) {
                    alt22=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 22, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:195:8: '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"'
                    {
                    match('\"'); 
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:195:12: ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )*
                    loop20:
                    do {
                        int alt20=3;
                        int LA20_0 = input.LA(1);

                        if ( (LA20_0=='\\') ) {
                            alt20=1;
                        }
                        else if ( ((LA20_0>='\u0000' && LA20_0<='!')||(LA20_0>='#' && LA20_0<='[')||(LA20_0>=']' && LA20_0<='\uFFFF')) ) {
                            alt20=2;
                        }


                        switch (alt20) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:195:14: ESC_SEQ
                    	    {
                    	    mESC_SEQ(); 

                    	    }
                    	    break;
                    	case 2 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:195:24: ~ ( '\\\\' | '\"' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop20;
                        }
                    } while (true);

                    match('\"'); 

                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:196:8: '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"'
                    {
                    match("\"\"\""); 

                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:196:14: (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )*
                    loop21:
                    do {
                        int alt21=4;
                        int LA21_0 = input.LA(1);

                        if ( (LA21_0=='\"') ) {
                            int LA21_1 = input.LA(2);

                            if ( (LA21_1=='\"') ) {
                                int LA21_3 = input.LA(3);

                                if ( ((LA21_3>='\u0000' && LA21_3<='!')||(LA21_3>='#' && LA21_3<='\uFFFF')) ) {
                                    alt21=3;
                                }


                            }
                            else if ( ((LA21_1>='\u0000' && LA21_1<='!')||(LA21_1>='#' && LA21_1<='\uFFFF')) ) {
                                alt21=2;
                            }


                        }
                        else if ( ((LA21_0>='\u0000' && LA21_0<='!')||(LA21_0>='#' && LA21_0<='\uFFFF')) ) {
                            alt21=1;
                        }


                        switch (alt21) {
                    	case 1 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:196:16: ~ ( '\"' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;
                    	case 2 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:196:25: '\"' ~ ( '\"' )
                    	    {
                    	    match('\"'); 
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;
                    	case 3 :
                    	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:196:38: '\"\"' ~ ( '\"' )
                    	    {
                    	    match("\"\""); 

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

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop21;
                        }
                    } while (true);

                    match("\"\"\""); 


                    }
                    break;

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

    // $ANTLR start "URI"
    public final void mURI() throws RecognitionException {
        try {
            int _type = URI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:200:5: ( '<http:' (~ ( '>' ) )* '>' )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:200:8: '<http:' (~ ( '>' ) )* '>'
            {
            match("<http:"); 

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:200:17: (~ ( '>' ) )*
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( ((LA23_0>='\u0000' && LA23_0<='=')||(LA23_0>='?' && LA23_0<='\uFFFF')) ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:200:19: ~ ( '>' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='=')||(input.LA(1)>='?' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop23;
                }
            } while (true);

            match('>'); 

            }

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

    // $ANTLR start "EXPONENT"
    public final void mEXPONENT() throws RecognitionException {
        try {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:204:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:204:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
            {
            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:204:22: ( '+' | '-' )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0=='+'||LA24_0=='-') ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:
                    {
                    if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;

            }

            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:204:33: ( '0' .. '9' )+
            int cnt25=0;
            loop25:
            do {
                int alt25=2;
                int LA25_0 = input.LA(1);

                if ( ((LA25_0>='0' && LA25_0<='9')) ) {
                    alt25=1;
                }


                switch (alt25) {
            	case 1 :
            	    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:204:34: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt25 >= 1 ) break loop25;
                        EarlyExitException eee =
                            new EarlyExitException(25, input);
                        throw eee;
                }
                cnt25++;
            } while (true);


            }

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

    // $ANTLR start "HEX_DIGIT"
    public final void mHEX_DIGIT() throws RecognitionException {
        try {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:207:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:207:13: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
            {
            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

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

    // $ANTLR start "ESC_SEQ"
    public final void mESC_SEQ() throws RecognitionException {
        try {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:211:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0=='\\') ) {
                int LA26_1 = input.LA(2);

                if ( (LA26_1=='\"'||LA26_1=='\''||LA26_1=='\\'||LA26_1=='b'||LA26_1=='f'||LA26_1=='n'||LA26_1=='r'||LA26_1=='t') ) {
                    alt26=1;
                }
                else if ( (LA26_1=='u') ) {
                    alt26=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 26, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }
            switch (alt26) {
                case 1 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:211:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); 
                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:212:9: UNICODE_ESC
                    {
                    mUNICODE_ESC(); 

                    }
                    break;

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

    // $ANTLR start "UNICODE_ESC"
    public final void mUNICODE_ESC() throws RecognitionException {
        try {
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:217:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
            // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:217:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
            {
            match('\\'); 
            match('u'); 
            mHEX_DIGIT(); 
            mHEX_DIGIT(); 
            mHEX_DIGIT(); 
            mHEX_DIGIT(); 

            }

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

    public void mTokens() throws RecognitionException {
        // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:8: ( T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | ID | COMMENT | WS | LPAREN | RPAREN | LBRACKET | RBRACKET | LCURLY | RCURLY | INT_RANGE | RANGE | NEWLINE | INDENT | DEDENT | INT | FLOAT | STRING | URI )
        int alt27=34;
        alt27 = dfa27.predict(input);
        switch (alt27) {
            case 1 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:10: T__65
                {
                mT__65(); 

                }
                break;
            case 2 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:16: T__66
                {
                mT__66(); 

                }
                break;
            case 3 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:22: T__67
                {
                mT__67(); 

                }
                break;
            case 4 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:28: T__68
                {
                mT__68(); 

                }
                break;
            case 5 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:34: T__69
                {
                mT__69(); 

                }
                break;
            case 6 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:40: T__70
                {
                mT__70(); 

                }
                break;
            case 7 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:46: T__71
                {
                mT__71(); 

                }
                break;
            case 8 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:52: T__72
                {
                mT__72(); 

                }
                break;
            case 9 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:58: T__73
                {
                mT__73(); 

                }
                break;
            case 10 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:64: T__74
                {
                mT__74(); 

                }
                break;
            case 11 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:70: T__75
                {
                mT__75(); 

                }
                break;
            case 12 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:76: T__76
                {
                mT__76(); 

                }
                break;
            case 13 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:82: T__77
                {
                mT__77(); 

                }
                break;
            case 14 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:88: T__78
                {
                mT__78(); 

                }
                break;
            case 15 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:94: T__79
                {
                mT__79(); 

                }
                break;
            case 16 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:100: T__80
                {
                mT__80(); 

                }
                break;
            case 17 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:106: ID
                {
                mID(); 

                }
                break;
            case 18 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:109: COMMENT
                {
                mCOMMENT(); 

                }
                break;
            case 19 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:117: WS
                {
                mWS(); 

                }
                break;
            case 20 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:120: LPAREN
                {
                mLPAREN(); 

                }
                break;
            case 21 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:127: RPAREN
                {
                mRPAREN(); 

                }
                break;
            case 22 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:134: LBRACKET
                {
                mLBRACKET(); 

                }
                break;
            case 23 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:143: RBRACKET
                {
                mRBRACKET(); 

                }
                break;
            case 24 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:152: LCURLY
                {
                mLCURLY(); 

                }
                break;
            case 25 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:159: RCURLY
                {
                mRCURLY(); 

                }
                break;
            case 26 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:166: INT_RANGE
                {
                mINT_RANGE(); 

                }
                break;
            case 27 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:176: RANGE
                {
                mRANGE(); 

                }
                break;
            case 28 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:182: NEWLINE
                {
                mNEWLINE(); 

                }
                break;
            case 29 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:190: INDENT
                {
                mINDENT(); 

                }
                break;
            case 30 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:197: DEDENT
                {
                mDEDENT(); 

                }
                break;
            case 31 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:204: INT
                {
                mINT(); 

                }
                break;
            case 32 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:208: FLOAT
                {
                mFLOAT(); 

                }
                break;
            case 33 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:214: STRING
                {
                mSTRING(); 

                }
                break;
            case 34 :
                // src\\org\\simantics\\graph\\compiler\\internal\\parsing\\Graph.g:1:221: URI
                {
                mURI(); 

                }
                break;

        }

    }


    protected DFA8 dfa8 = new DFA8(this);
    protected DFA7 dfa7 = new DFA7(this);
    protected DFA19 dfa19 = new DFA19(this);
    protected DFA27 dfa27 = new DFA27(this);
    static final String DFA8_eotS =
        "\10\uffff";
    static final String DFA8_eofS =
        "\10\uffff";
    static final String DFA8_minS =
        "\1\55\1\60\1\56\1\uffff\1\56\1\uffff\1\55\1\uffff";
    static final String DFA8_maxS =
        "\2\71\1\145\1\uffff\1\145\1\uffff\1\71\1\uffff";
    static final String DFA8_acceptS =
        "\3\uffff\1\2\1\uffff\1\1\1\uffff\1\3";
    static final String DFA8_specialS =
        "\10\uffff}>";
    static final String[] DFA8_transitionS = {
            "\1\1\1\3\1\uffff\12\2",
            "\12\2",
            "\1\4\1\uffff\12\2\13\uffff\1\5\37\uffff\1\5",
            "",
            "\1\6\1\uffff\12\5\13\uffff\1\5\37\uffff\1\5",
            "",
            "\1\7\1\5\1\uffff\12\7",
            ""
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "132:1: RANGE : ( FLOAT '..' ( FLOAT | INT )? | '..' FLOAT | INT '..' FLOAT );";
        }
    }
    static final String DFA7_eotS =
        "\1\3\1\uffff\1\5\3\uffff";
    static final String DFA7_eofS =
        "\6\uffff";
    static final String DFA7_minS =
        "\1\55\1\60\1\56\3\uffff";
    static final String DFA7_maxS =
        "\2\71\1\145\3\uffff";
    static final String DFA7_acceptS =
        "\3\uffff\1\3\1\1\1\2";
    static final String DFA7_specialS =
        "\6\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\1\2\uffff\12\2",
            "\12\2",
            "\1\4\1\uffff\12\2\13\uffff\1\4\37\uffff\1\4",
            "",
            "",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "132:24: ( FLOAT | INT )?";
        }
    }
    static final String DFA19_eotS =
        "\4\uffff";
    static final String DFA19_eofS =
        "\4\uffff";
    static final String DFA19_minS =
        "\1\60\1\56\2\uffff";
    static final String DFA19_maxS =
        "\1\71\1\145\2\uffff";
    static final String DFA19_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA19_specialS =
        "\4\uffff}>";
    static final String[] DFA19_transitionS = {
            "\12\1",
            "\1\2\1\uffff\12\1\13\uffff\1\3\37\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
    static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
    static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
    static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
    static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
    static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
    static final short[][] DFA19_transition;

    static {
        int numStates = DFA19_transitionS.length;
        DFA19_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA19_transition[i] = DFA.unpackEncodedString(DFA19_transitionS[i]);
        }
    }

    class DFA19 extends DFA {

        public DFA19(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 19;
            this.eot = DFA19_eot;
            this.eof = DFA19_eof;
            this.min = DFA19_min;
            this.max = DFA19_max;
            this.accept = DFA19_accept;
            this.special = DFA19_special;
            this.transition = DFA19_transition;
        }
        public String getDescription() {
            return "189:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )";
        }
    }
    static final String DFA27_eotS =
        "\2\uffff\1\35\2\uffff\1\44\6\uffff\3\32\10\uffff\1\50\1\uffff\1"+
        "\32\13\uffff\3\32\1\uffff\1\64\1\uffff\1\32\1\uffff\1\70\3\32\1"+
        "\70\1\64\3\uffff\1\64\1\32\2\uffff\1\102\2\32\1\uffff\1\70\1\uffff"+
        "\1\64\1\32\1\uffff\1\106\2\32\1\uffff\1\111\1\112\4\uffff";
    static final String DFA27_eofS =
        "\115\uffff";
    static final String DFA27_minS =
        "\1\11\1\uffff\1\56\2\55\1\75\6\uffff\1\162\1\141\1\116\10\uffff"+
        "\1\56\1\uffff\1\105\2\uffff\1\55\10\uffff\1\165\1\154\1\104\1\uffff"+
        "\1\56\1\53\1\104\1\60\1\56\1\145\1\163\1\105\1\55\1\56\1\53\1\uffff"+
        "\1\60\1\56\1\105\2\uffff\1\60\1\145\1\116\1\60\1\56\1\60\1\56\1"+
        "\116\1\uffff\1\60\2\124\1\uffff\2\60\2\0\2\uffff";
    static final String DFA27_maxS =
        "\1\175\1\uffff\1\56\1\150\1\71\1\75\6\uffff\1\162\1\141\1\116\10"+
        "\uffff\1\145\1\uffff\1\105\2\uffff\1\71\10\uffff\1\165\1\154\1\104"+
        "\1\uffff\1\145\1\71\1\104\1\71\2\145\1\163\1\105\1\71\1\145\1\71"+
        "\1\uffff\2\71\1\105\2\uffff\1\172\1\145\1\116\1\71\1\145\2\71\1"+
        "\116\1\uffff\1\172\2\124\1\uffff\2\172\2\0\2\uffff";
    static final String DFA27_acceptS =
        "\1\uffff\1\1\4\uffff\1\10\1\11\1\13\1\14\1\15\1\16\3\uffff\1\22"+
        "\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\uffff\1\34\1\uffff\1\21\1"+
        "\41\1\uffff\1\2\1\3\1\4\1\5\1\42\1\6\1\7\1\12\3\uffff\1\37\13\uffff"+
        "\1\40\3\uffff\1\32\1\33\10\uffff\1\17\3\uffff\1\20\4\uffff\1\35"+
        "\1\36";
    static final String DFA27_specialS =
        "\111\uffff\1\1\1\0\2\uffff}>";
    static final String[] DFA27_transitionS = {
            "\1\20\1\30\2\uffff\1\20\22\uffff\1\20\1\uffff\1\33\1\uffff"+
            "\1\11\1\10\2\uffff\1\21\1\22\2\uffff\1\13\1\4\1\2\1\17\12\27"+
            "\1\7\1\uffff\1\3\1\5\1\6\1\uffff\1\1\3\32\1\31\4\32\1\16\21"+
            "\32\1\23\1\uffff\1\24\1\uffff\1\32\1\uffff\5\32\1\15\15\32\1"+
            "\14\6\32\1\25\1\12\1\26",
            "",
            "\1\34",
            "\1\40\44\uffff\1\37\1\uffff\1\36\23\uffff\1\41",
            "\1\42\2\uffff\12\27",
            "\1\43",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\45",
            "\1\46",
            "\1\47",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\51\1\uffff\12\27\13\uffff\1\52\37\uffff\1\52",
            "",
            "\1\53",
            "",
            "",
            "\1\54\2\uffff\12\55",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\56",
            "\1\57",
            "\1\60",
            "",
            "\1\61\1\uffff\12\62\13\uffff\1\63\37\uffff\1\63",
            "\1\65\1\uffff\1\65\2\uffff\12\66",
            "\1\67",
            "\12\55",
            "\1\71\1\uffff\12\55\13\uffff\1\71\37\uffff\1\71",
            "\1\72",
            "\1\73",
            "\1\74",
            "\1\75\1\71\1\uffff\12\76",
            "\1\71\1\uffff\12\62\13\uffff\1\63\37\uffff\1\63",
            "\1\77\1\uffff\1\77\2\uffff\12\100",
            "",
            "\12\66",
            "\1\71\1\uffff\12\66",
            "\1\101",
            "",
            "",
            "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
            "\1\103",
            "\1\104",
            "\12\76",
            "\1\71\1\uffff\12\76\13\uffff\1\71\37\uffff\1\71",
            "\12\100",
            "\1\71\1\uffff\12\100",
            "\1\105",
            "",
            "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
            "\1\107",
            "\1\110",
            "",
            "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
            "\12\32\7\uffff\32\32\4\uffff\1\32\1\uffff\32\32",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
    static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
    static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
    static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
    static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
    static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
    static final short[][] DFA27_transition;

    static {
        int numStates = DFA27_transitionS.length;
        DFA27_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
        }
    }

    class DFA27 extends DFA {

        public DFA27(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | ID | COMMENT | WS | LPAREN | RPAREN | LBRACKET | RBRACKET | LCURLY | RCURLY | INT_RANGE | RANGE | NEWLINE | INDENT | DEDENT | INT | FLOAT | STRING | URI );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA27_74 = input.LA(1);

                         
                        int index27_74 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (!((( false )))) ) {s = 26;}

                        else if ( (( false )) ) {s = 76;}

                         
                        input.seek(index27_74);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA27_73 = input.LA(1);

                         
                        int index27_73 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (!((( false )))) ) {s = 26;}

                        else if ( (( false )) ) {s = 75;}

                         
                        input.seek(index27_73);
                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 27, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

}