# pylint: disable=line-too-long

class Parser(object):
    def __init__(self, msg, fname, starting_rule='grammar'):
        self.msg = msg
        self.end = len(msg)
        self.fname = fname
        self.starting_rule = starting_rule
        self.val = None
        self.err = None
        self.pos = 0
        self.errpos = 0
        self.errset = set()
        self.scopes = []

    def parse(self):
        rule_fn = getattr(self, '_' + self.starting_rule + '_', None)
        if not rule_fn:
            return None, 'unknown rule "%s"' % self.starting_rule
        rule_fn()
        if self.err:
            return None, self._err_str()
        return self.val, None

    def _push(self, name):
        self.scopes.append((name, {}))

    def _pop(self, name):
        actual_name, _ = self.scopes.pop()
        assert name == actual_name

    def _get(self, var):
        return self.scopes[-1][1][var]

    def _set(self, var, val):
        self.scopes[-1][1][var] = val

    def _err_str(self):
        lineno, colno, _ = self._err_offsets()
        prefix = '%s:%d' % (self.fname, lineno)
        if isinstance(self.err, basestring):
            return '%s %s' % (prefix, self.err)
        exps = list(self.errset)
        if len(exps) > 1:
            return '%s Unexpected "%s" at column %d' % (
                prefix, self.msg[self.errpos], colno)
        return '%s Expecting a "%s" at column %d, got a "%s"' % (
                prefix, exps[0], colno, self.msg[self.errpos])

    def _err_offsets(self):
        lineno = 1
        colno = 1
        i = 0
        begpos = 0
        while i < self.errpos:
            if self.msg[i] == '\n':
                lineno += 1
                colno = 1
                begpos = i
            else:
                colno += 1
            i += 1
        return lineno, colno, begpos

    def _esc(self, val):
        return str(val)

    def _expect(self, expr):
        p = self.pos
        l = len(expr)
        if (p + l <= self.end) and self.msg[p:p + l] == expr:
            self.pos += l
            self.val = expr
            self.err = False
        else:
            self.val = None
            self.err = True
            if self.pos >= self.errpos:
                if self.pos > self.errpos:
                    self.errset = set()
                self.errset.add(self._esc(expr))
                self.errpos = self.pos
        return

    def _grammar_(self):
        self._push('grammar')
        self._sp_()
        if self.err:
            self._pop('grammar')
            return
        self._value_()
        if not self.err:
            self._set('v', self.val)
        if self.err:
            self._pop('grammar')
            return
        self._sp_()
        if self.err:
            self._pop('grammar')
            return
        self._end_()
        if self.err:
            self._pop('grammar')
            return
        self.val = self._get('v')
        self.err = None
        self._pop('grammar')

    def _sp_(self):
        vs = []
        while not self.err:
            p = self.pos
            self._ws_()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None

    def _ws_(self):
        p = self.pos
        def choice_0():
            self._expect(' ')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('\t')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._eol_()
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._comment_()
        choice_3()

    def _eol_(self):
        p = self.pos
        def choice_0():
            self._expect('\r\n')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('\r')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._expect('\n')
        choice_2()

    def _comment_(self):
        p = self.pos
        def choice_0():
            self._expect('//')
            if self.err:
                return
            vs = []
            while not self.err:
                p = self.pos
                def group():
                    p = self.pos
                    def group():
                        p = self.pos
                        def choice_0():
                            self._eol_()
                        choice_0()
                        if not self.err:
                            return

                        self.err = False
                        self.pos = p
                        def choice_1():
                            self._end_()
                        choice_1()
                    group()
                    self.pos = p
                    if not self.err:
                        self.err = "not"
                        self.val = None
                        return
                    self.err = None
                    if self.err:
                        return
                    self._anything_()
                group()
                if not self.err:
                    vs.append(self.val)
                else:
                    self.pos = p
            self.val = vs
            self.err = None
            if self.err:
                return
            def group():
                p = self.pos
                def choice_0():
                    self._end_()
                choice_0()
                if not self.err:
                    return

                self.err = False
                self.pos = p
                def choice_1():
                    self._eol_()
                choice_1()
            group()
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('/*')
            if self.err:
                return
            vs = []
            while not self.err:
                p = self.pos
                def group():
                    p = self.pos
                    self._expect('*/')
                    self.pos = p
                    if not self.err:
                        self.err = "not"
                        self.val = None
                        return
                    self.err = None
                    if self.err:
                        return
                    self._anything_()
                group()
                if not self.err:
                    vs.append(self.val)
                else:
                    self.pos = p
            self.val = vs
            self.err = None
            if self.err:
                return
            self._expect('*/')
        choice_1()

    def _value_(self):
        p = self.pos
        def choice_0():
            self._expect('null')
            if self.err:
                return
            self.val = 'None'
            self.err = None
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('true')
            if self.err:
                return
            self.val = 'True'
            self.err = None
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._expect('false')
            if self.err:
                return
            self.val = 'False'
            self.err = None
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._push('value_3')
            self._object_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('value_3')
                return
            self.val = ['object', self._get('v')]
            self.err = None
            self._pop('value_3')
        choice_3()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_4():
            self._push('value_4')
            self._array_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('value_4')
                return
            self.val = ['array', self._get('v')]
            self.err = None
            self._pop('value_4')
        choice_4()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_5():
            self._push('value_5')
            self._string_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('value_5')
                return
            self.val = ['string', self._get('v')]
            self.err = None
            self._pop('value_5')
        choice_5()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_6():
            self._push('value_6')
            self._num_literal_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('value_6')
                return
            self.val = ['number', self._get('v')]
            self.err = None
            self._pop('value_6')
        choice_6()

    def _object_(self):
        p = self.pos
        def choice_0():
            self._push('object_0')
            self._expect('{')
            if self.err:
                self._pop('object_0')
                return
            self._sp_()
            if self.err:
                self._pop('object_0')
                return
            self._member_list_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('object_0')
                return
            self._sp_()
            if self.err:
                self._pop('object_0')
                return
            self._expect('}')
            if self.err:
                self._pop('object_0')
                return
            self.val = self._get('v')
            self.err = None
            self._pop('object_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('{')
            if self.err:
                return
            self._sp_()
            if self.err:
                return
            self._expect('}')
            if self.err:
                return
            self.val = []
            self.err = None
        choice_1()

    def _array_(self):
        p = self.pos
        def choice_0():
            self._push('array_0')
            self._expect('[')
            if self.err:
                self._pop('array_0')
                return
            self._sp_()
            if self.err:
                self._pop('array_0')
                return
            self._element_list_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('array_0')
                return
            self._sp_()
            if self.err:
                self._pop('array_0')
                return
            self._expect(']')
            if self.err:
                self._pop('array_0')
                return
            self.val = self._get('v')
            self.err = None
            self._pop('array_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('[')
            if self.err:
                return
            self._sp_()
            if self.err:
                return
            self._expect(']')
            if self.err:
                return
            self.val = []
            self.err = None
        choice_1()

    def _string_(self):
        p = self.pos
        def choice_0():
            self._push('string_0')
            self._squote_()
            if self.err:
                self._pop('string_0')
                return
            self._sqchars_()
            if not self.err:
                self._set('s', self.val)
            if self.err:
                self._pop('string_0')
                return
            self._squote_()
            if self.err:
                self._pop('string_0')
                return
            self.val = self._get('s')
            self.err = None
            self._pop('string_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('string_1')
            self._dquote_()
            if self.err:
                self._pop('string_1')
                return
            self._dqchars_()
            if not self.err:
                self._set('s', self.val)
            if self.err:
                self._pop('string_1')
                return
            self._dquote_()
            if self.err:
                self._pop('string_1')
                return
            self.val = self._get('s')
            self.err = None
            self._pop('string_1')
        choice_1()

    def _sqchars_(self):
        self._push('sqchars')
        vs = []
        while not self.err:
            p = self.pos
            def group():
                p = self.pos
                def group():
                    p = self.pos
                    def choice_0():
                        self._squote_()
                    choice_0()
                    if not self.err:
                        return

                    self.err = False
                    self.pos = p
                    def choice_1():
                        self._eol_()
                    choice_1()
                group()
                self.pos = p
                if not self.err:
                    self.err = "not"
                    self.val = None
                    return
                self.err = None
                if self.err:
                    return
                self._sqchar_()
            group()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None
        if not self.err:
            self._set('cs', self.val)
        if self.err:
            self._pop('sqchars')
            return
        self.val = ''.join(self._get('cs'))
        self.err = None
        self._pop('sqchars')

    def _sqchar_(self):
        p = self.pos
        def choice_0():
            self._bslash_()
            if self.err:
                return
            self._squote_()
            if self.err:
                return
            self.val = '\x5C\x27'
            self.err = None
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._bslash_()
            if self.err:
                return
            self._expect('\n')
            if self.err:
                return
            self.val = '\n'
            self.err = None
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._bslash_()
            if self.err:
                return
            self._expect('\r\n')
            if self.err:
                return
            self.val = '\r\n'
            self.err = None
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._bslash_()
            if self.err:
                return
            self._expect('\r')
            if self.err:
                return
            self.val = '\r'
            self.err = None
        choice_3()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_4():
            self._bslash_()
            if self.err:
                return
            self._bslash_()
            if self.err:
                return
            self.val = '\x5C\x5C'
            self.err = None
        choice_4()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_5():
            self._anything_()
        choice_5()

    def _dqchars_(self):
        self._push('dqchars')
        vs = []
        while not self.err:
            p = self.pos
            def group():
                p = self.pos
                def group():
                    p = self.pos
                    def choice_0():
                        self._dquote_()
                    choice_0()
                    if not self.err:
                        return

                    self.err = False
                    self.pos = p
                    def choice_1():
                        self._eol_()
                    choice_1()
                group()
                self.pos = p
                if not self.err:
                    self.err = "not"
                    self.val = None
                    return
                self.err = None
                if self.err:
                    return
                self._dqchar_()
            group()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None
        if not self.err:
            self._set('cs', self.val)
        if self.err:
            self._pop('dqchars')
            return
        self.val = ''.join(self._get('cs'))
        self.err = None
        self._pop('dqchars')

    def _dqchar_(self):
        p = self.pos
        def choice_0():
            self._bslash_()
            if self.err:
                return
            self._dquote_()
            if self.err:
                return
            self.val = '\x5C\x22'
            self.err = None
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._bslash_()
            if self.err:
                return
            self._expect('\n')
            if self.err:
                return
            self.val = '\n'
            self.err = None
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._bslash_()
            if self.err:
                return
            self._expect('\r\n')
            if self.err:
                return
            self.val = '\r\n'
            self.err = None
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._bslash_()
            if self.err:
                return
            self._expect('\r')
            if self.err:
                return
            self.val = '\r'
            self.err = None
        choice_3()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_4():
            self._bslash_()
            if self.err:
                return
            self._bslash_()
            if self.err:
                return
            self.val = '\x5C\x5C'
            self.err = None
        choice_4()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_5():
            self._anything_()
        choice_5()

    def _bslash_(self):
        self._expect('\x5C')

    def _squote_(self):
        self._expect('\x27')

    def _dquote_(self):
        self._expect('\x22')

    def _element_list_(self):
        p = self.pos
        def choice_0():
            self._push('element_list_0')
            self._value_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('element_list_0')
                return
            self._sp_()
            if self.err:
                self._pop('element_list_0')
                return
            self._expect(',')
            if self.err:
                self._pop('element_list_0')
                return
            self._sp_()
            if self.err:
                self._pop('element_list_0')
                return
            self._element_list_()
            if not self.err:
                self._set('vs', self.val)
            if self.err:
                self._pop('element_list_0')
                return
            self.val = [self._get('v')] + self._get('vs')
            self.err = None
            self._pop('element_list_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('element_list_1')
            self._value_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('element_list_1')
                return
            self._sp_()
            if self.err:
                self._pop('element_list_1')
                return
            self._expect(',')
            if self.err:
                self._pop('element_list_1')
                return
            self.val = [self._get('v')]
            self.err = None
            self._pop('element_list_1')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._push('element_list_2')
            self._value_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('element_list_2')
                return
            self.val = [self._get('v')]
            self.err = None
            self._pop('element_list_2')
        choice_2()

    def _member_list_(self):
        p = self.pos
        def choice_0():
            self._push('member_list_0')
            self._member_()
            if not self.err:
                self._set('m', self.val)
            if self.err:
                self._pop('member_list_0')
                return
            self._sp_()
            if self.err:
                self._pop('member_list_0')
                return
            self._expect(',')
            if self.err:
                self._pop('member_list_0')
                return
            self._sp_()
            if self.err:
                self._pop('member_list_0')
                return
            self._member_list_()
            if not self.err:
                self._set('ms', self.val)
            if self.err:
                self._pop('member_list_0')
                return
            self.val = [self._get('m')] + self._get('ms')
            self.err = None
            self._pop('member_list_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('member_list_1')
            self._member_()
            if not self.err:
                self._set('m', self.val)
            if self.err:
                self._pop('member_list_1')
                return
            self._sp_()
            if self.err:
                self._pop('member_list_1')
                return
            self._expect(',')
            if self.err:
                self._pop('member_list_1')
                return
            self.val = [self._get('m')]
            self.err = None
            self._pop('member_list_1')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._push('member_list_2')
            self._member_()
            if not self.err:
                self._set('m', self.val)
            if self.err:
                self._pop('member_list_2')
                return
            self.val = [self._get('m')]
            self.err = None
            self._pop('member_list_2')
        choice_2()

    def _member_(self):
        p = self.pos
        def choice_0():
            self._push('member_0')
            self._string_()
            if not self.err:
                self._set('k', self.val)
            if self.err:
                self._pop('member_0')
                return
            self._sp_()
            if self.err:
                self._pop('member_0')
                return
            self._expect(':')
            if self.err:
                self._pop('member_0')
                return
            self._sp_()
            if self.err:
                self._pop('member_0')
                return
            self._value_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('member_0')
                return
            self.val = [self._get('k'), self._get('v')]
            self.err = None
            self._pop('member_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('member_1')
            self._ident_()
            if not self.err:
                self._set('k', self.val)
            if self.err:
                self._pop('member_1')
                return
            self._sp_()
            if self.err:
                self._pop('member_1')
                return
            self._expect(':')
            if self.err:
                self._pop('member_1')
                return
            self._sp_()
            if self.err:
                self._pop('member_1')
                return
            self._value_()
            if not self.err:
                self._set('v', self.val)
            if self.err:
                self._pop('member_1')
                return
            self.val = [self._get('k'), self._get('v')]
            self.err = None
            self._pop('member_1')
        choice_1()

    def _ident_(self):
        self._push('ident')
        self._id_start_()
        if not self.err:
            self._set('hd', self.val)
        if self.err:
            self._pop('ident')
            return
        vs = []
        while not self.err:
            p = self.pos
            self._id_continue_()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None
        if not self.err:
            self._set('tl', self.val)
        if self.err:
            self._pop('ident')
            return
        self.val = ''.join([self._get('hd')] + self._get('tl'))
        self.err = None
        self._pop('ident')

    def _id_start_(self):
        p = self.pos
        def choice_0():
            self._letter_()
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._expect('$')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._expect('_')
        choice_2()

    def _id_continue_(self):
        p = self.pos
        def choice_0():
            self._id_start_()
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._digit_()
        choice_1()

    def _num_literal_(self):
        p = self.pos
        def choice_0():
            self._push('num_literal_0')
            self._expect('-')
            if self.err:
                self._pop('num_literal_0')
                return
            self._num_literal_()
            if not self.err:
                self._set('n', self.val)
            if self.err:
                self._pop('num_literal_0')
                return
            self.val = '-' + self._get('n')
            self.err = None
            self._pop('num_literal_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('num_literal_1')
            p = self.pos
            self._expect('+')
            if self.err:
                self.val = []
                self.err = None
                self.pos = p
            else:
                self.val = [self.val]
            if self.err:
                self._pop('num_literal_1')
                return
            self._dec_literal_()
            if not self.err:
                self._set('d', self.val)
            if self.err:
                self._pop('num_literal_1')
                return
            p = self.pos
            def group():
                p = self.pos
                def choice_0():
                    self._id_start_()
                choice_0()
                if not self.err:
                    return

                self.err = False
                self.pos = p
                def choice_1():
                    self._digit_()
                choice_1()
            group()
            self.pos = p
            if not self.err:
                self.err = "not"
                self.val = None
                self._pop('num_literal_1')
                return
            self.err = None
            if self.err:
                self._pop('num_literal_1')
                return
            self.val = self._get('d')
            self.err = None
            self._pop('num_literal_1')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._hex_literal_()
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._expect('Infinity')
        choice_3()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_4():
            self._expect('NaN')
        choice_4()

    def _dec_literal_(self):
        p = self.pos
        def choice_0():
            self._push('dec_literal_0')
            self._dec_int_lit_()
            if not self.err:
                self._set('d', self.val)
            if self.err:
                self._pop('dec_literal_0')
                return
            self._frac_()
            if not self.err:
                self._set('f', self.val)
            if self.err:
                self._pop('dec_literal_0')
                return
            self._exp_()
            if not self.err:
                self._set('e', self.val)
            if self.err:
                self._pop('dec_literal_0')
                return
            self.val = self._get('d') + self._get('f') + self._get('e')
            self.err = None
            self._pop('dec_literal_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('dec_literal_1')
            self._dec_int_lit_()
            if not self.err:
                self._set('d', self.val)
            if self.err:
                self._pop('dec_literal_1')
                return
            self._frac_()
            if not self.err:
                self._set('f', self.val)
            if self.err:
                self._pop('dec_literal_1')
                return
            self.val = self._get('d') + self._get('f')
            self.err = None
            self._pop('dec_literal_1')
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._push('dec_literal_2')
            self._dec_int_lit_()
            if not self.err:
                self._set('d', self.val)
            if self.err:
                self._pop('dec_literal_2')
                return
            self._exp_()
            if not self.err:
                self._set('e', self.val)
            if self.err:
                self._pop('dec_literal_2')
                return
            self.val = self._get('d') + self._get('e')
            self.err = None
            self._pop('dec_literal_2')
        choice_2()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_3():
            self._push('dec_literal_3')
            self._dec_int_lit_()
            if not self.err:
                self._set('d', self.val)
            if self.err:
                self._pop('dec_literal_3')
                return
            self.val = self._get('d')
            self.err = None
            self._pop('dec_literal_3')
        choice_3()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_4():
            self._push('dec_literal_4')
            self._frac_()
            if not self.err:
                self._set('f', self.val)
            if self.err:
                self._pop('dec_literal_4')
                return
            self._exp_()
            if not self.err:
                self._set('e', self.val)
            if self.err:
                self._pop('dec_literal_4')
                return
            self.val = self._get('f') + self._get('e')
            self.err = None
            self._pop('dec_literal_4')
        choice_4()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_5():
            self._push('dec_literal_5')
            self._frac_()
            if not self.err:
                self._set('f', self.val)
            if self.err:
                self._pop('dec_literal_5')
                return
            self.val = self._get('f')
            self.err = None
            self._pop('dec_literal_5')
        choice_5()

    def _dec_int_lit_(self):
        p = self.pos
        def choice_0():
            self._expect('0')
            if self.err:
                return
            p = self.pos
            self._digit_()
            self.pos = p
            if not self.err:
                self.err = "not"
                self.val = None
                return
            self.err = None
            if self.err:
                return
            self.val = '0'
            self.err = None
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('dec_int_lit_1')
            self._nonzerodigit_()
            if not self.err:
                self._set('n', self.val)
            if self.err:
                self._pop('dec_int_lit_1')
                return
            vs = []
            while not self.err:
                p = self.pos
                self._digit_()
                if not self.err:
                    vs.append(self.val)
                else:
                    self.pos = p
            self.val = vs
            self.err = None
            if not self.err:
                self._set('ds', self.val)
            if self.err:
                self._pop('dec_int_lit_1')
                return
            self.val = self._get('n') + ''.join(self._get('ds'))
            self.err = None
            self._pop('dec_int_lit_1')
        choice_1()

    def _nonzerodigit_(self):
        i = u'1'
        j = u'9'
        if (self.pos == self.end or
            ord(self.msg[self.pos]) < ord(i) or
            ord(self.msg[self.pos]) > ord(j)):
            self.val = None
            self.err = True
            if self.pos >= self.errpos:
                if self.pos > self.errpos:
                    self.errset = set()
                self.errset.add('something between %s and %s' % (i, j))
                self.errpos = self.pos
        else:
            self.val = self.msg[self.pos]
            self.err = False
            self.pos += 1
        return

    def _hex_literal_(self):
        self._push('hex_literal')
        def group():
            p = self.pos
            def choice_0():
                self._expect('0x')
            choice_0()
            if not self.err:
                return

            self.err = False
            self.pos = p
            def choice_1():
                self._expect('0X')
            choice_1()
        group()
        if self.err:
            self._pop('hex_literal')
            return
        vs = []
        self._hex_digit_()
        if self.err:
            self._pop('hex_literal')
            return
        vs.append(self.val)
        while not self.err:
            p = self.pos
            self._hex_digit_()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None
        if not self.err:
            self._set('hs', self.val)
        if self.err:
            self._pop('hex_literal')
            return
        self.val = '0x' + ''.join(self._get('hs'))
        self.err = None
        self._pop('hex_literal')

    def _hex_digit_(self):
        p = self.pos
        def choice_0():
            i = u'a'
            j = u'f'
            if (self.pos == self.end or
                ord(self.msg[self.pos]) < ord(i) or
                ord(self.msg[self.pos]) > ord(j)):
                self.val = None
                self.err = True
                if self.pos >= self.errpos:
                    if self.pos > self.errpos:
                        self.errset = set()
                    self.errset.add('something between %s and %s' % (i, j))
                    self.errpos = self.pos
            else:
                self.val = self.msg[self.pos]
                self.err = False
                self.pos += 1
            return
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            i = u'A'
            j = u'F'
            if (self.pos == self.end or
                ord(self.msg[self.pos]) < ord(i) or
                ord(self.msg[self.pos]) > ord(j)):
                self.val = None
                self.err = True
                if self.pos >= self.errpos:
                    if self.pos > self.errpos:
                        self.errset = set()
                    self.errset.add('something between %s and %s' % (i, j))
                    self.errpos = self.pos
            else:
                self.val = self.msg[self.pos]
                self.err = False
                self.pos += 1
            return
        choice_1()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_2():
            self._digit_()
        choice_2()

    def _frac_(self):
        self._push('frac')
        self._expect('.')
        if self.err:
            self._pop('frac')
            return
        vs = []
        while not self.err:
            p = self.pos
            self._digit_()
            if not self.err:
                vs.append(self.val)
            else:
                self.pos = p
        self.val = vs
        self.err = None
        if not self.err:
            self._set('ds', self.val)
        if self.err:
            self._pop('frac')
            return
        self.val = '.' + ''.join(self._get('ds'))
        self.err = None
        self._pop('frac')

    def _exp_(self):
        p = self.pos
        def choice_0():
            self._push('exp_0')
            def group():
                p = self.pos
                def choice_0():
                    self._expect('e')
                choice_0()
                if not self.err:
                    return

                self.err = False
                self.pos = p
                def choice_1():
                    self._expect('E')
                choice_1()
            group()
            if self.err:
                self._pop('exp_0')
                return
            def group():
                p = self.pos
                def choice_0():
                    self._expect('+')
                choice_0()
                if not self.err:
                    return

                self.err = False
                self.pos = p
                def choice_1():
                    self._expect('-')
                choice_1()
            group()
            if not self.err:
                self._set('s', self.val)
            if self.err:
                self._pop('exp_0')
                return
            vs = []
            while not self.err:
                p = self.pos
                self._digit_()
                if not self.err:
                    vs.append(self.val)
                else:
                    self.pos = p
            self.val = vs
            self.err = None
            if not self.err:
                self._set('ds', self.val)
            if self.err:
                self._pop('exp_0')
                return
            self.val = 'e' + self._get('s') + ''.join(self._get('ds'))
            self.err = None
            self._pop('exp_0')
        choice_0()
        if not self.err:
            return

        self.err = False
        self.pos = p
        def choice_1():
            self._push('exp_1')
            def group():
                p = self.pos
                def choice_0():
                    self._expect('e')
                choice_0()
                if not self.err:
                    return

                self.err = False
                self.pos = p
                def choice_1():
                    self._expect('E')
                choice_1()
            group()
            if self.err:
                self._pop('exp_1')
                return
            vs = []
            while not self.err:
                p = self.pos
                self._digit_()
                if not self.err:
                    vs.append(self.val)
                else:
                    self.pos = p
            self.val = vs
            self.err = None
            if not self.err:
                self._set('ds', self.val)
            if self.err:
                self._pop('exp_1')
                return
            self.val = 'e' + ''.join(self._get('ds'))
            self.err = None
            self._pop('exp_1')
        choice_1()

    def _anything_(self):
        if self.pos < self.end:
            self.val = self.msg[self.pos]
            self.err = None
            self.pos += 1
        else:
            self.val = None
            self.err = "anything"

    def _digit_(self):
        if self.pos < self.end and self.msg[self.pos].isdigit():
            self.val = self.msg[self.pos]
            self.err = None
            self.pos += 1
        else:
            self.val = None
            self.err = "a digit"
        return

    def _end_(self):
        if self.pos == self.end:
            self.val = None
            self.err = None
        else:
            self.val = None
            self.err = "the end"
        return

    def _letter_(self):
        if self.pos < self.end and self.msg[self.pos].isalpha():
            self.val = self.msg[self.pos]
            self.err = None
            self.pos += 1
        else:
            self.val = None
            self.err = "a letter"
        return