# $ANTLR 3.1.3 Mar 18, 2009 10:09:25 AccessControl.g 2013-02-06 18:11:31

import sys
from antlr3 import *
from antlr3.compat import set, frozenset


# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

# token types
T__29=29
T__28=28
T__27=27
T__26=26
T__25=25
T__24=24
T__23=23
T__22=22
T__21=21
T__20=20
INT=6
PATHPREFIX=5
ID=4
EOF=-1
T__9=9
T__30=30
T__19=19
T__16=16
WS=8
T__15=15
T__18=18
T__17=17
T__12=12
T__11=11
T__14=14
T__13=13
T__10=10
COMMENT=7


class AccessControlLexer(Lexer):

    grammarFileName = "AccessControl.g"
    antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
    antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"

    def __init__(self, input=None, state=None):
        if state is None:
            state = RecognizerSharedState()
        super(AccessControlLexer, self).__init__(input, state)


        self.dfa10 = self.DFA10(
            self, 10,
            eot = self.DFA10_eot,
            eof = self.DFA10_eof,
            min = self.DFA10_min,
            max = self.DFA10_max,
            accept = self.DFA10_accept,
            special = self.DFA10_special,
            transition = self.DFA10_transition
            )






    # $ANTLR start "T__9"
    def mT__9(self, ):

        try:
            _type = T__9
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:7:6: ( 'type' )
            # AccessControl.g:7:8: 'type'
            pass 
            self.match("type")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__9"



    # $ANTLR start "T__10"
    def mT__10(self, ):

        try:
            _type = T__10
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:8:7: ( ';' )
            # AccessControl.g:8:9: ';'
            pass 
            self.match(59)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__10"



    # $ANTLR start "T__11"
    def mT__11(self, ):

        try:
            _type = T__11
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:9:7: ( ',' )
            # AccessControl.g:9:9: ','
            pass 
            self.match(44)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__11"



    # $ANTLR start "T__12"
    def mT__12(self, ):

        try:
            _type = T__12
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:10:7: ( 'domain' )
            # AccessControl.g:10:9: 'domain'
            pass 
            self.match("domain")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__12"



    # $ANTLR start "T__13"
    def mT__13(self, ):

        try:
            _type = T__13
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:11:7: ( '=' )
            # AccessControl.g:11:9: '='
            pass 
            self.match(61)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__13"



    # $ANTLR start "T__14"
    def mT__14(self, ):

        try:
            _type = T__14
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:12:7: ( '(' )
            # AccessControl.g:12:9: '('
            pass 
            self.match(40)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__14"



    # $ANTLR start "T__15"
    def mT__15(self, ):

        try:
            _type = T__15
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:13:7: ( ')' )
            # AccessControl.g:13:9: ')'
            pass 
            self.match(41)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__15"



    # $ANTLR start "T__16"
    def mT__16(self, ):

        try:
            _type = T__16
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:14:7: ( 'setauth' )
            # AccessControl.g:14:9: 'setauth'
            pass 
            self.match("setauth")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__16"



    # $ANTLR start "T__17"
    def mT__17(self, ):

        try:
            _type = T__17
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:15:7: ( '->' )
            # AccessControl.g:15:9: '->'
            pass 
            self.match("->")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__17"



    # $ANTLR start "T__18"
    def mT__18(self, ):

        try:
            _type = T__18
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:16:7: ( 'auto' )
            # AccessControl.g:16:9: 'auto'
            pass 
            self.match("auto")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__18"



    # $ANTLR start "T__19"
    def mT__19(self, ):

        try:
            _type = T__19
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:17:7: ( 'exec' )
            # AccessControl.g:17:9: 'exec'
            pass 
            self.match("exec")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__19"



    # $ANTLR start "T__20"
    def mT__20(self, ):

        try:
            _type = T__20
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:18:7: ( 'initial_domain' )
            # AccessControl.g:18:9: 'initial_domain'
            pass 
            self.match("initial_domain")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__20"



    # $ANTLR start "T__21"
    def mT__21(self, ):

        try:
            _type = T__21
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:19:7: ( 'assign' )
            # AccessControl.g:19:9: 'assign'
            pass 
            self.match("assign")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__21"



    # $ANTLR start "T__22"
    def mT__22(self, ):

        try:
            _type = T__22
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:20:7: ( '-r' )
            # AccessControl.g:20:9: '-r'
            pass 
            self.match("-r")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__22"



    # $ANTLR start "T__23"
    def mT__23(self, ):

        try:
            _type = T__23
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:21:7: ( '-s' )
            # AccessControl.g:21:9: '-s'
            pass 
            self.match("-s")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__23"



    # $ANTLR start "T__24"
    def mT__24(self, ):

        try:
            _type = T__24
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:22:7: ( '{' )
            # AccessControl.g:22:9: '{'
            pass 
            self.match(123)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__24"



    # $ANTLR start "T__25"
    def mT__25(self, ):

        try:
            _type = T__25
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:23:7: ( '}' )
            # AccessControl.g:23:9: '}'
            pass 
            self.match(125)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__25"



    # $ANTLR start "T__26"
    def mT__26(self, ):

        try:
            _type = T__26
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:24:7: ( 'clearances' )
            # AccessControl.g:24:9: 'clearances'
            pass 
            self.match("clearances")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__26"



    # $ANTLR start "T__27"
    def mT__27(self, ):

        try:
            _type = T__27
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:25:7: ( ':' )
            # AccessControl.g:25:9: ':'
            pass 
            self.match(58)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__27"



    # $ANTLR start "T__28"
    def mT__28(self, ):

        try:
            _type = T__28
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:26:7: ( '<' )
            # AccessControl.g:26:9: '<'
            pass 
            self.match(60)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__28"



    # $ANTLR start "T__29"
    def mT__29(self, ):

        try:
            _type = T__29
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:27:7: ( 'categories' )
            # AccessControl.g:27:9: 'categories'
            pass 
            self.match("categories")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__29"



    # $ANTLR start "T__30"
    def mT__30(self, ):

        try:
            _type = T__30
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:28:7: ( 'users' )
            # AccessControl.g:28:9: 'users'
            pass 
            self.match("users")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__30"



    # $ANTLR start "ID"
    def mID(self, ):

        try:
            _type = ID
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:311:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            # AccessControl.g:311:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            pass 
            if (65 <= self.input.LA(1) <= 90) or self.input.LA(1) == 95 or (97 <= self.input.LA(1) <= 122):
                self.input.consume()
            else:
                mse = MismatchedSetException(None, self.input)
                self.recover(mse)
                raise mse

            # AccessControl.g:311:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            while True: #loop1
                alt1 = 2
                LA1_0 = self.input.LA(1)

                if ((48 <= LA1_0 <= 57) or (65 <= LA1_0 <= 90) or LA1_0 == 95 or (97 <= LA1_0 <= 122)) :
                    alt1 = 1


                if alt1 == 1:
                    # AccessControl.g:
                    pass 
                    if (48 <= self.input.LA(1) <= 57) or (65 <= self.input.LA(1) <= 90) or self.input.LA(1) == 95 or (97 <= self.input.LA(1) <= 122):
                        self.input.consume()
                    else:
                        mse = MismatchedSetException(None, self.input)
                        self.recover(mse)
                        raise mse



                else:
                    break #loop1



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ID"



    # $ANTLR start "INT"
    def mINT(self, ):

        try:
            _type = INT
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:314:5: ( ( '0' .. '9' )+ )
            # AccessControl.g:314:7: ( '0' .. '9' )+
            pass 
            # AccessControl.g:314:7: ( '0' .. '9' )+
            cnt2 = 0
            while True: #loop2
                alt2 = 2
                LA2_0 = self.input.LA(1)

                if ((48 <= LA2_0 <= 57)) :
                    alt2 = 1


                if alt2 == 1:
                    # AccessControl.g:314:7: '0' .. '9'
                    pass 
                    self.matchRange(48, 57)


                else:
                    if cnt2 >= 1:
                        break #loop2

                    eee = EarlyExitException(2, self.input)
                    raise eee

                cnt2 += 1



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "INT"



    # $ANTLR start "COMMENT"
    def mCOMMENT(self, ):

        try:
            _type = COMMENT
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:318:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )
            alt6 = 2
            LA6_0 = self.input.LA(1)

            if (LA6_0 == 35) :
                alt6 = 1
            elif (LA6_0 == 47) :
                alt6 = 2
            else:
                nvae = NoViableAltException("", 6, 0, self.input)

                raise nvae

            if alt6 == 1:
                # AccessControl.g:318:9: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
                pass 
                self.match(35)
                # AccessControl.g:318:13: (~ ( '\\n' | '\\r' ) )*
                while True: #loop3
                    alt3 = 2
                    LA3_0 = self.input.LA(1)

                    if ((0 <= LA3_0 <= 9) or (11 <= LA3_0 <= 12) or (14 <= LA3_0 <= 65535)) :
                        alt3 = 1


                    if alt3 == 1:
                        # AccessControl.g:318:13: ~ ( '\\n' | '\\r' )
                        pass 
                        if (0 <= self.input.LA(1) <= 9) or (11 <= self.input.LA(1) <= 12) or (14 <= self.input.LA(1) <= 65535):
                            self.input.consume()
                        else:
                            mse = MismatchedSetException(None, self.input)
                            self.recover(mse)
                            raise mse



                    else:
                        break #loop3
                # AccessControl.g:318:27: ( '\\r' )?
                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == 13) :
                    alt4 = 1
                if alt4 == 1:
                    # AccessControl.g:318:27: '\\r'
                    pass 
                    self.match(13)



                self.match(10)
                #action start
                _channel=HIDDEN;
                #action end


            elif alt6 == 2:
                # AccessControl.g:319:9: '/*' ( options {greedy=false; } : . )* '*/'
                pass 
                self.match("/*")
                # AccessControl.g:319:14: ( options {greedy=false; } : . )*
                while True: #loop5
                    alt5 = 2
                    LA5_0 = self.input.LA(1)

                    if (LA5_0 == 42) :
                        LA5_1 = self.input.LA(2)

                        if (LA5_1 == 47) :
                            alt5 = 2
                        elif ((0 <= LA5_1 <= 46) or (48 <= LA5_1 <= 65535)) :
                            alt5 = 1


                    elif ((0 <= LA5_0 <= 41) or (43 <= LA5_0 <= 65535)) :
                        alt5 = 1


                    if alt5 == 1:
                        # AccessControl.g:319:42: .
                        pass 
                        self.matchAny()


                    else:
                        break #loop5
                self.match("*/")
                #action start
                _channel=HIDDEN;
                #action end


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "COMMENT"



    # $ANTLR start "WS"
    def mWS(self, ):

        try:
            _type = WS
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:322:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
            # AccessControl.g:322:9: ( ' ' | '\\t' | '\\r' | '\\n' )
            pass 
            if (9 <= self.input.LA(1) <= 10) or self.input.LA(1) == 13 or self.input.LA(1) == 32:
                self.input.consume()
            else:
                mse = MismatchedSetException(None, self.input)
                self.recover(mse)
                raise mse

            #action start
            _channel=HIDDEN;
            #action end



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "WS"



    # $ANTLR start "PATHPREFIX"
    def mPATHPREFIX(self, ):

        try:
            _type = PATHPREFIX
            _channel = DEFAULT_CHANNEL

            # AccessControl.g:329:12: ( ( '/' | ( '/' ID )+ ( '/' )? ) )
            # AccessControl.g:329:14: ( '/' | ( '/' ID )+ ( '/' )? )
            pass 
            # AccessControl.g:329:14: ( '/' | ( '/' ID )+ ( '/' )? )
            alt9 = 2
            LA9_0 = self.input.LA(1)

            if (LA9_0 == 47) :
                LA9_1 = self.input.LA(2)

                if ((65 <= LA9_1 <= 90) or LA9_1 == 95 or (97 <= LA9_1 <= 122)) :
                    alt9 = 2
                else:
                    alt9 = 1
            else:
                nvae = NoViableAltException("", 9, 0, self.input)

                raise nvae

            if alt9 == 1:
                # AccessControl.g:329:15: '/'
                pass 
                self.match(47)


            elif alt9 == 2:
                # AccessControl.g:329:21: ( '/' ID )+ ( '/' )?
                pass 
                # AccessControl.g:329:21: ( '/' ID )+
                cnt7 = 0
                while True: #loop7
                    alt7 = 2
                    LA7_0 = self.input.LA(1)

                    if (LA7_0 == 47) :
                        LA7_1 = self.input.LA(2)

                        if ((65 <= LA7_1 <= 90) or LA7_1 == 95 or (97 <= LA7_1 <= 122)) :
                            alt7 = 1




                    if alt7 == 1:
                        # AccessControl.g:329:22: '/' ID
                        pass 
                        self.match(47)
                        self.mID()


                    else:
                        if cnt7 >= 1:
                            break #loop7

                        eee = EarlyExitException(7, self.input)
                        raise eee

                    cnt7 += 1
                # AccessControl.g:329:31: ( '/' )?
                alt8 = 2
                LA8_0 = self.input.LA(1)

                if (LA8_0 == 47) :
                    alt8 = 1
                if alt8 == 1:
                    # AccessControl.g:329:32: '/'
                    pass 
                    self.match(47)









            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PATHPREFIX"



    def mTokens(self):
        # AccessControl.g:1:8: ( T__9 | T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | ID | INT | COMMENT | WS | PATHPREFIX )
        alt10 = 27
        alt10 = self.dfa10.predict(self.input)
        if alt10 == 1:
            # AccessControl.g:1:10: T__9
            pass 
            self.mT__9()


        elif alt10 == 2:
            # AccessControl.g:1:15: T__10
            pass 
            self.mT__10()


        elif alt10 == 3:
            # AccessControl.g:1:21: T__11
            pass 
            self.mT__11()


        elif alt10 == 4:
            # AccessControl.g:1:27: T__12
            pass 
            self.mT__12()


        elif alt10 == 5:
            # AccessControl.g:1:33: T__13
            pass 
            self.mT__13()


        elif alt10 == 6:
            # AccessControl.g:1:39: T__14
            pass 
            self.mT__14()


        elif alt10 == 7:
            # AccessControl.g:1:45: T__15
            pass 
            self.mT__15()


        elif alt10 == 8:
            # AccessControl.g:1:51: T__16
            pass 
            self.mT__16()


        elif alt10 == 9:
            # AccessControl.g:1:57: T__17
            pass 
            self.mT__17()


        elif alt10 == 10:
            # AccessControl.g:1:63: T__18
            pass 
            self.mT__18()


        elif alt10 == 11:
            # AccessControl.g:1:69: T__19
            pass 
            self.mT__19()


        elif alt10 == 12:
            # AccessControl.g:1:75: T__20
            pass 
            self.mT__20()


        elif alt10 == 13:
            # AccessControl.g:1:81: T__21
            pass 
            self.mT__21()


        elif alt10 == 14:
            # AccessControl.g:1:87: T__22
            pass 
            self.mT__22()


        elif alt10 == 15:
            # AccessControl.g:1:93: T__23
            pass 
            self.mT__23()


        elif alt10 == 16:
            # AccessControl.g:1:99: T__24
            pass 
            self.mT__24()


        elif alt10 == 17:
            # AccessControl.g:1:105: T__25
            pass 
            self.mT__25()


        elif alt10 == 18:
            # AccessControl.g:1:111: T__26
            pass 
            self.mT__26()


        elif alt10 == 19:
            # AccessControl.g:1:117: T__27
            pass 
            self.mT__27()


        elif alt10 == 20:
            # AccessControl.g:1:123: T__28
            pass 
            self.mT__28()


        elif alt10 == 21:
            # AccessControl.g:1:129: T__29
            pass 
            self.mT__29()


        elif alt10 == 22:
            # AccessControl.g:1:135: T__30
            pass 
            self.mT__30()


        elif alt10 == 23:
            # AccessControl.g:1:141: ID
            pass 
            self.mID()


        elif alt10 == 24:
            # AccessControl.g:1:144: INT
            pass 
            self.mINT()


        elif alt10 == 25:
            # AccessControl.g:1:148: COMMENT
            pass 
            self.mCOMMENT()


        elif alt10 == 26:
            # AccessControl.g:1:156: WS
            pass 
            self.mWS()


        elif alt10 == 27:
            # AccessControl.g:1:159: PATHPREFIX
            pass 
            self.mPATHPREFIX()







    # lookup tables for DFA #10

    DFA10_eot = DFA.unpack(
        u"\1\uffff\1\23\2\uffff\1\23\3\uffff\1\23\1\uffff\3\23\2\uffff\1"
        u"\23\2\uffff\1\23\3\uffff\1\45\1\uffff\3\23\3\uffff\7\23\1\uffff"
        u"\12\23\1\72\2\23\1\75\1\23\1\77\4\23\1\uffff\2\23\1\uffff\1\23"
        u"\1\uffff\3\23\1\112\1\113\1\23\1\115\3\23\2\uffff\1\121\1\uffff"
        u"\3\23\1\uffff\7\23\1\134\1\135\1\23\2\uffff\2\23\1\141\1\uffff"
        )

    DFA10_eof = DFA.unpack(
        u"\142\uffff"
        )

    DFA10_min = DFA.unpack(
        u"\1\11\1\171\2\uffff\1\157\3\uffff\1\145\1\76\1\163\1\170\1\156"
        u"\2\uffff\1\141\2\uffff\1\163\3\uffff\1\52\1\uffff\1\160\1\155\1"
        u"\164\3\uffff\1\164\1\163\1\145\1\151\1\145\1\164\1\145\1\uffff"
        u"\1\145\2\141\1\157\1\151\1\143\1\164\1\141\1\145\1\162\1\60\1\151"
        u"\1\165\1\60\1\147\1\60\1\151\1\162\1\147\1\163\1\uffff\1\156\1"
        u"\164\1\uffff\1\156\1\uffff\2\141\1\157\2\60\1\150\1\60\1\154\1"
        u"\156\1\162\2\uffff\1\60\1\uffff\1\137\1\143\1\151\1\uffff\1\144"
        u"\2\145\1\157\2\163\1\155\2\60\1\141\2\uffff\1\151\1\156\1\60\1"
        u"\uffff"
        )

    DFA10_max = DFA.unpack(
        u"\1\175\1\171\2\uffff\1\157\3\uffff\1\145\1\163\1\165\1\170\1\156"
        u"\2\uffff\1\154\2\uffff\1\163\3\uffff\1\52\1\uffff\1\160\1\155\1"
        u"\164\3\uffff\1\164\1\163\1\145\1\151\1\145\1\164\1\145\1\uffff"
        u"\1\145\2\141\1\157\1\151\1\143\1\164\1\141\1\145\1\162\1\172\1"
        u"\151\1\165\1\172\1\147\1\172\1\151\1\162\1\147\1\163\1\uffff\1"
        u"\156\1\164\1\uffff\1\156\1\uffff\2\141\1\157\2\172\1\150\1\172"
        u"\1\154\1\156\1\162\2\uffff\1\172\1\uffff\1\137\1\143\1\151\1\uffff"
        u"\1\144\2\145\1\157\2\163\1\155\2\172\1\141\2\uffff\1\151\1\156"
        u"\1\172\1\uffff"
        )

    DFA10_accept = DFA.unpack(
        u"\2\uffff\1\2\1\3\1\uffff\1\5\1\6\1\7\5\uffff\1\20\1\21\1\uffff"
        u"\1\23\1\24\1\uffff\1\27\1\30\1\31\1\uffff\1\32\3\uffff\1\11\1\16"
        u"\1\17\7\uffff\1\33\24\uffff\1\1\2\uffff\1\12\1\uffff\1\13\12\uffff"
        u"\1\26\1\4\1\uffff\1\15\3\uffff\1\10\12\uffff\1\22\1\25\3\uffff"
        u"\1\14"
        )

    DFA10_special = DFA.unpack(
        u"\142\uffff"
        )

            
    DFA10_transition = [
        DFA.unpack(u"\2\27\2\uffff\1\27\22\uffff\1\27\2\uffff\1\25\4\uffff"
        u"\1\6\1\7\2\uffff\1\3\1\11\1\uffff\1\26\12\24\1\20\1\2\1\21\1\5"
        u"\3\uffff\32\23\4\uffff\1\23\1\uffff\1\12\1\23\1\17\1\4\1\13\3\23"
        u"\1\14\11\23\1\10\1\1\1\22\5\23\1\15\1\uffff\1\16"),
        DFA.unpack(u"\1\30"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\31"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\32"),
        DFA.unpack(u"\1\33\63\uffff\1\34\1\35"),
        DFA.unpack(u"\1\37\1\uffff\1\36"),
        DFA.unpack(u"\1\40"),
        DFA.unpack(u"\1\41"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\43\12\uffff\1\42"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\44"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\25"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\46"),
        DFA.unpack(u"\1\47"),
        DFA.unpack(u"\1\50"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\51"),
        DFA.unpack(u"\1\52"),
        DFA.unpack(u"\1\53"),
        DFA.unpack(u"\1\54"),
        DFA.unpack(u"\1\55"),
        DFA.unpack(u"\1\56"),
        DFA.unpack(u"\1\57"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\60"),
        DFA.unpack(u"\1\61"),
        DFA.unpack(u"\1\62"),
        DFA.unpack(u"\1\63"),
        DFA.unpack(u"\1\64"),
        DFA.unpack(u"\1\65"),
        DFA.unpack(u"\1\66"),
        DFA.unpack(u"\1\67"),
        DFA.unpack(u"\1\70"),
        DFA.unpack(u"\1\71"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\73"),
        DFA.unpack(u"\1\74"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\76"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\100"),
        DFA.unpack(u"\1\101"),
        DFA.unpack(u"\1\102"),
        DFA.unpack(u"\1\103"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\104"),
        DFA.unpack(u"\1\105"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\106"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\107"),
        DFA.unpack(u"\1\110"),
        DFA.unpack(u"\1\111"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\114"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\116"),
        DFA.unpack(u"\1\117"),
        DFA.unpack(u"\1\120"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\122"),
        DFA.unpack(u"\1\123"),
        DFA.unpack(u"\1\124"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\125"),
        DFA.unpack(u"\1\126"),
        DFA.unpack(u"\1\127"),
        DFA.unpack(u"\1\130"),
        DFA.unpack(u"\1\131"),
        DFA.unpack(u"\1\132"),
        DFA.unpack(u"\1\133"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"\1\136"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\137"),
        DFA.unpack(u"\1\140"),
        DFA.unpack(u"\12\23\7\uffff\32\23\4\uffff\1\23\1\uffff\32\23"),
        DFA.unpack(u"")
    ]

    # class definition for DFA #10

    class DFA10(DFA):
        pass


 



def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
    from antlr3.main import LexerMain
    main = LexerMain(AccessControlLexer)
    main.stdin = stdin
    main.stdout = stdout
    main.stderr = stderr
    main.execute(argv)


if __name__ == '__main__':
    main(sys.argv)
